{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Comparing 3 Deep Neural Networks Trained to Predict a Stocks Closing Price\n",
    "\n",
    "### Can you teach a deep neural network (dnn) to predict a stock's closing price?\n",
    "\n",
    "This notebook compares 3 dnn's trained to predict a stock's closing price from an algorithm's backtest trading history to see how smart you can make a dnn.\n",
    "\n",
    "This notebook examines:\n",
    "\n",
    "1. Which [activation function **ReLU** vs **Sigmoid**](https://keras.io/activations/) is better?\n",
    "2. If preprocessing the input trading history dataset using a [MinMaxScaler](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html#sklearn.preprocessing.MinMaxScaler) leads to better predictions and less errors?\n",
    "\n",
    "### Let's take a look!\n",
    "\n",
    "#### Background\n",
    "\n",
    "This notebook was created using many custom indicators and the [Analysis Engine](https://github.com/AlgoTraders/stock-analysis-engine). It enables a user to roll new, custom AI training datasets from minute-by-minute, intraday algorithm backtests. Each algorithm backtest creates and publishes its trading history to S3 (Minio or AWS). These trading histories are compressed [pandas DataFrames](http://pandas.pydata.org/pandas-docs/stable/reference/frame.html) where the algorithm's indicator decisions are stored as columns within the trading history's DataFrame. These columns become training features for a dnn to learn and hopefully make better predictions than the **control** dnn."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### How it works\n",
    "\n",
    "#### Before Running the Notebook\n",
    "\n",
    "1. Run through [Getting Started with the Analysis Engine](https://github.com/AlgoTraders/stock-analysis-engine#getting-started)\n",
    "\n",
    "1. [Publish a Trading History from an Algorithm's Backtest to S3](https://github.com/AlgoTraders/stock-analysis-engine#run-a-local-backtest-and-publish-algorithm-trading-history-to-s3)\n",
    "\n",
    "```\n",
    "ae -t SPY -p s3://algohistory/algo_training_SPY.json\n",
    "```\n",
    "\n",
    "#### Getting Started\n",
    "\n",
    "1. Load the Runtime\n",
    "\n",
    "1. Set Training Parameters\n",
    "\n",
    "1. Load the Trading History from S3\n",
    "\n",
    "1. Prepare Training Datasets from Trading History\n",
    "   \n",
    "   - Prepare a **control** dataset without any preprocessing and only use the **high** + **low** + **open** columns (3 wide) to predict the **close**\n",
    "   - Prepare a **test** dataset using a MinMaxScaler with all numeric columns (895 wide) to predict the **close**\n",
    "\n",
    "1. Create the Training Dataset Splits\n",
    "\n",
    "1. Build and Compile 3 KerasRegressors using Keras + Tensorflow + Scikit-learn\n",
    "\n",
    "    - Create **control** DNN without a MinMaxScaler\n",
    "    - Create **test-relu** DNN with MinMaxScaler with **ReLU** activation\n",
    "    - Create **test-sigmoid** DNN with MinMaxScaler with **Sigmoid** activation\n",
    "\n",
    "1. Fit (train)\n",
    "\n",
    "    - Fit **control** dataset (3 columns wide) with **control** DNN\n",
    "    - Fit **test** dataset (895 columns wide) with **test-relu** DNN\n",
    "    - Fit **test** dataset (895 columns wide) with **test-sigmoid** DNN\n",
    "\n",
    "1. Determine Errors (MSE + MAE + MAPE + CP)\n",
    "\n",
    "1. Run Predictions\n",
    "\n",
    "1. Plot Historical Close vs DNNs' Predicted Close "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Runtime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "starting - 2019-01-28 18:50:52.779997\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "imports done - 2019-01-28 18:50:55.819923\n",
      "ready - 2019-01-28 18:50:55.822446\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "\n",
    "print(f'starting - {datetime.datetime.now()}')\n",
    "\n",
    "import copy\n",
    "import numpy as np\n",
    "import numpy.random as np_random\n",
    "import pandas as pd\n",
    "import pandas.api.types as pandas_types\n",
    "import sklearn.model_selection as tt_split\n",
    "import keras.wrappers.scikit_learn as keras_scikit\n",
    "import tensorflow as tf\n",
    "import analysis_engine.consts as ae_consts\n",
    "import analysis_engine.load_history_dataset as load_history\n",
    "import analysis_engine.ai.build_regression_dnn as build_dnn\n",
    "import analysis_engine.ai.build_datasets_using_scalers as build_scaler_datasets\n",
    "import analysis_engine.ai.build_scaler_dataset_from_df as build_scaler_df\n",
    "import analysis_engine.ai.plot_dnn_fit_history as plot_fit_history\n",
    "import analysis_engine.plot_trading_history as plot_trading_history\n",
    "\n",
    "print(f'imports done - {datetime.datetime.now()}')\n",
    "\n",
    "# ensure reproducible results tip from:\n",
    "# https://machinelearningmastery.com/reproducible-results-neural-networks-keras/\n",
    "np_random.seed(1)\n",
    "\n",
    "print(f'ready - {datetime.datetime.now()}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set Training Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "predict_feature = 'close'\n",
    "use_epochs = 20\n",
    "use_batch_size = 10\n",
    "use_test_size = 0.1\n",
    "use_random_state = 1\n",
    "use_seed = 7\n",
    "use_shuffle = False\n",
    "model_verbose = True\n",
    "control_fit_verbose = False\n",
    "relu_fit_verbose = False\n",
    "sigmoid_fit_verbose = False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set Algorithm's S3 Bucket and Key Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# change these to your values:\n",
    "s3_bucket = (\n",
    "    f'algohistory')\n",
    "s3_key = (\n",
    "    f'algo_training_SPY.json')\n",
    "\n",
    "s3_access_key = ae_consts.S3_ACCESS_KEY\n",
    "s3_secret_key = ae_consts.S3_SECRET_KEY\n",
    "s3_region_name = ae_consts.S3_REGION_NAME\n",
    "s3_address = ae_consts.S3_ADDRESS\n",
    "s3_secure = ae_consts.S3_SECURE\n",
    "compress = True\n",
    "created_on = (\n",
    "    datetime.datetime.now().strftime(\n",
    "        ae_consts.COMMON_TICK_DATE_FORMAT))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load the Trading History from S3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loaded trading history from s3://algohistory/algo_training_SPY.json\n"
     ]
    }
   ],
   "source": [
    "load_res = load_history.load_history_dataset(\n",
    "    s3_key=s3_key,\n",
    "    s3_address=s3_address,\n",
    "    s3_bucket=s3_bucket,\n",
    "    s3_access_key=s3_access_key,\n",
    "    s3_secret_key=s3_secret_key,\n",
    "    s3_region_name=s3_region_name,\n",
    "    s3_secure=s3_secure,\n",
    "    compress=compress)\n",
    "\n",
    "ticker = None\n",
    "if 'tickers' not in load_res:\n",
    "    print(\n",
    "        f'unable to load trading history from s3://{s3_address}/{s3_bucket}/{s3_key}')\n",
    "else:\n",
    "    tickers = load_res.get(\n",
    "        'tickers',\n",
    "        [\n",
    "            'SPY',\n",
    "        ])\n",
    "    ticker = tickers[0]\n",
    "    print(\n",
    "        f'loaded trading history from s3://{s3_bucket}/{s3_key}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prepare Training Datasets from Trading History"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "prepared training data from history algohistory@algo_training_SPY.json rows=396 dates: 2019-01-18 16:00:00 to 2019-01-28 15:59:00\n",
      "control dnn num features=3\n",
      "test dnn num features=895\n",
      "predicting: close from trading history with rows=396\n"
     ]
    }
   ],
   "source": [
    "df = load_res[ticker]\n",
    "df['date'] = pd.to_datetime(\n",
    "    df['date'])\n",
    "df['minute'] = pd.to_datetime(\n",
    "    df['minute'])\n",
    "df_filter = (df['close'] >= 0.1)\n",
    "ticker = df['ticker'].iloc[0]\n",
    "first_date = df['date'].iloc[0]\n",
    "end_date = df['date'].iloc[-1]\n",
    "\n",
    "if 'minute' in df:\n",
    "    found_valid_minute = df['minute'].iloc[0]\n",
    "    if found_valid_minute:\n",
    "        first_date = df['minute'].iloc[0]\n",
    "        end_date = df['minute'].iloc[-1]\n",
    "\n",
    "date_str = (\n",
    "    f'Dates: {df[df_filter][\"minute\"].iloc[0]} '\n",
    "    f'to '\n",
    "    f'{df[df_filter][\"minute\"].iloc[-1]}')\n",
    "    \n",
    "num_rows = len(df.index)\n",
    "\n",
    "print(\n",
    "    f'prepared training data from history {s3_bucket}@{s3_key} '\n",
    "    f'rows={num_rows} '\n",
    "    f'dates: {first_date} to {end_date}')\n",
    "\n",
    "predict_feature = 'close'\n",
    "control_train_features = [\n",
    "    'high',\n",
    "    'low',\n",
    "    'open'\n",
    "]\n",
    "control_all_features = [\n",
    "    predict_feature\n",
    "] + control_train_features\n",
    "\n",
    "all_features = [\n",
    "    predict_feature\n",
    "]\n",
    "train_features = []\n",
    "for c in df.columns.values:\n",
    "    if pandas_types.is_numeric_dtype(df[c]) and c not in train_features:\n",
    "        if c != predict_feature:\n",
    "            train_features.append(c)\n",
    "        if c not in all_features:\n",
    "            all_features.append(c)\n",
    "\n",
    "features_and_minute = [\n",
    "    'minute'\n",
    "] + all_features\n",
    "num_control_features = len(control_train_features)\n",
    "num_features = len(train_features)\n",
    "\n",
    "print(\n",
    "    f'control dnn num features={num_control_features}')\n",
    "print(\n",
    "    f'test dnn num features={num_features}')\n",
    "print(\n",
    "    f'predicting: {predict_feature} from trading history with rows={len(df.index)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Numeric Datasets from Features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "converting rows=390 to float32 data\n",
      "building control train and test dfs from subset of features\n",
      "control train rows=390 and test rows=390 test columns=['close']\n",
      "building test scaler datasets for relu and sigmoid dnns\n",
      "scaler train rows=390 and test rows=390\n"
     ]
    }
   ],
   "source": [
    "print(\n",
    "    f'converting rows={len(df[df_filter].index)} to float32 data')\n",
    "timeseries_df = df[df_filter].fillna(-10000.0)\n",
    "converted_df = timeseries_df[all_features].astype('float32')\n",
    "\n",
    "print(\n",
    "    f'building control train and test dfs from subset of features')\n",
    "control_train_df = converted_df[control_train_features].copy()\n",
    "control_test_df = converted_df[[predict_feature]].copy()\n",
    "print(\n",
    "    f'control train rows={len(control_train_df.index)} and test rows={len(control_test_df.index)} test columns={control_test_df.columns.values}')\n",
    "\n",
    "train_df = None\n",
    "test_df = None\n",
    "x_train = None\n",
    "x_test = None\n",
    "y_train = None\n",
    "y_test = None\n",
    "scaler_predictions = None\n",
    "\n",
    "print(\n",
    "    f'building test scaler datasets for relu and sigmoid dnns')\n",
    "scaler_res = build_scaler_datasets.build_datasets_using_scalers(\n",
    "    train_features=train_features,\n",
    "    test_feature=predict_feature,\n",
    "    df=converted_df,\n",
    "    test_size=use_test_size,\n",
    "    seed=use_seed)\n",
    "if scaler_res['status'] != ae_consts.SUCCESS:\n",
    "    print(\n",
    "        'failed to build scaler train and test datasets for relu and sigmoid dnns')\n",
    "else:\n",
    "    train_df = scaler_res['scaled_train_df']\n",
    "    test_df = scaler_res['scaled_test_df']\n",
    "    x_train = scaler_res['x_train']\n",
    "    x_test = scaler_res['x_test']\n",
    "    y_train = scaler_res['y_train']\n",
    "    y_test = scaler_res['y_test']\n",
    "    scaler_predictions = scaler_res['scaler_test']\n",
    "    \n",
    "    print(\n",
    "        f'scaler train rows={len(train_df)} and test rows={len(test_df)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Prediction Records"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prediction scaler_rows=390 control=390\n"
     ]
    }
   ],
   "source": [
    "# on production use newly fetched pricing data not the training data\n",
    "control_predict_records = converted_df[control_train_features]\n",
    "predict_records = []\n",
    "prediction_res = build_scaler_df.build_scaler_dataset_from_df(\n",
    "    df=converted_df[train_features])\n",
    "if prediction_res['status'] == ae_consts.SUCCESS:\n",
    "    predict_records = prediction_res['df']\n",
    "    print(\n",
    "        f'Prediction scaler_rows={len(predict_records)} control={len(control_predict_records)}')\n",
    "else:\n",
    "    print(\n",
    "        f'failed building scaled prediction records')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Deep Neural Network Configs - Control + Relu + Sigmoid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "dnn_config = {\n",
    "    'layers': [\n",
    "        {\n",
    "            'num_neurons': 150,\n",
    "            'init': 'uniform',\n",
    "            'activation': 'relu'\n",
    "        },\n",
    "        {\n",
    "            'num_neurons': 100,\n",
    "            'init': 'uniform',\n",
    "            'activation': 'relu'\n",
    "        },\n",
    "        {\n",
    "            'num_neurons': 50,\n",
    "            'init': 'uniform',\n",
    "            'activation': 'relu'\n",
    "        },\n",
    "        {\n",
    "            'num_neurons': 1,\n",
    "            'init': 'uniform',\n",
    "            'activation': 'relu'\n",
    "        }\n",
    "    ]\n",
    "}\n",
    "\n",
    "dnn_relu_config = copy.deepcopy(dnn_config)\n",
    "dnn_sigmoid_config = copy.deepcopy(dnn_config)\n",
    "dnn_sigmoid_config['layers'][-1]['activation'] = 'sigmoid'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Keras Compile Config"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "compile_config = {\n",
    "    'loss': 'mse',\n",
    "    'optimizer': 'adam',\n",
    "    'metrics': [\n",
    "        'accuracy',\n",
    "        'mse',\n",
    "        'mae',\n",
    "        'mape',\n",
    "        'cosine'\n",
    "    ]\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build and Compile a KerasRegressors using Keras + Tensorflow + Scikit-learn"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Control DNN with ReLU Activation Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_control_model():\n",
    "    return build_dnn.build_regression_dnn(\n",
    "        num_features=num_control_features,\n",
    "        compile_config=compile_config,\n",
    "        model_config=dnn_config)\n",
    "\n",
    "dnn_control_estimator = keras_scikit.KerasRegressor(\n",
    "    build_fn=set_control_model,\n",
    "    epochs=use_epochs,\n",
    "    batch_size=use_batch_size,\n",
    "    verbose=model_verbose)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Test DNN with ReLU Activation Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_relu_model():\n",
    "    return build_dnn.build_regression_dnn(\n",
    "        num_features=num_features,\n",
    "        compile_config=compile_config,\n",
    "        model_config=dnn_relu_config)\n",
    "\n",
    "dnn_relu_estimator = keras_scikit.KerasRegressor(\n",
    "    build_fn=set_relu_model,\n",
    "    epochs=use_epochs,\n",
    "    batch_size=use_batch_size,\n",
    "    verbose=model_verbose)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Build Test DNN with Sigmoid Activation Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def set_sigmoid_model():\n",
    "    return build_dnn.build_regression_dnn(\n",
    "        num_features=num_features,\n",
    "        compile_config=compile_config,\n",
    "        model_config=dnn_sigmoid_config)\n",
    "\n",
    "dnn_sigmoid_estimator = keras_scikit.KerasRegressor(\n",
    "    build_fn=set_sigmoid_model,\n",
    "    epochs=use_epochs,\n",
    "    batch_size=use_batch_size,\n",
    "    verbose=model_verbose)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create the Training Dataset Splits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the Control Training Dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "control train_colums=['high' 'low' 'open'] test_column=['close']\n",
      "control data split breakdown - x_train=351 x_test=39 y_train=351 y_test=39\n"
     ]
    }
   ],
   "source": [
    "(control_x_train,\n",
    " control_x_test,\n",
    " control_y_train,\n",
    " control_y_test) = tt_split.train_test_split(\n",
    "     control_train_df,\n",
    "     control_test_df,\n",
    "     test_size=use_test_size,\n",
    "     random_state=use_random_state)\n",
    "\n",
    "print(\n",
    "    f'control train_colums={control_train_df.columns.values} test_column={control_test_df.columns.values}')\n",
    "\n",
    "print(\n",
    "    f'control data split breakdown - '\n",
    "    f'x_train={len(control_x_train)} '\n",
    "    f'x_test={len(control_x_test)} '\n",
    "    f'y_train={len(control_y_train)} '\n",
    "    f'y_test={len(control_y_test)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create the Training Scaler Datasets for the Relu and Sigmoid DNNs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "relu and sigmoid train_colums=895 test_column=close\n",
      "training data split breakdown relu and sigmoid - x_train=351 x_test=39 y_train=351 y_test=39\n"
     ]
    }
   ],
   "source": [
    "(x_train,\n",
    " x_test,\n",
    " y_train,\n",
    " y_test) = tt_split.train_test_split(\n",
    "     train_df,\n",
    "     test_df,\n",
    "     test_size=use_test_size,\n",
    "     random_state=use_random_state)\n",
    "\n",
    "print(\n",
    "    f'relu and sigmoid train_colums={len(train_features)} test_column={predict_feature}')\n",
    "\n",
    "print(\n",
    "    f'training data split breakdown relu and sigmoid - '\n",
    "    f'x_train={len(x_train)} '\n",
    "    f'x_test={len(x_test)} '\n",
    "    f'y_train={len(y_train)} '\n",
    "    f'y_test={len(y_test)}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fit the Control DNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "control - fitting estimator - predicting=close epochs=20 batch=10 test_size=0.1 seed=7\n"
     ]
    }
   ],
   "source": [
    "print(\n",
    "    f'control - fitting estimator - '\n",
    "    f'predicting={predict_feature} '\n",
    "    f'epochs={use_epochs} '\n",
    "    f'batch={use_batch_size} '\n",
    "    f'test_size={use_test_size} '\n",
    "    f'seed={use_seed}')\n",
    "    \n",
    "control_history = dnn_control_estimator.fit(\n",
    "    control_x_train,\n",
    "    control_y_train,\n",
    "    validation_data=(\n",
    "        control_x_train,\n",
    "        control_y_train),\n",
    "    epochs=use_epochs,\n",
    "    batch_size=use_batch_size,\n",
    "    shuffle=use_shuffle,\n",
    "    verbose=control_fit_verbose)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fit the Test ReLU DNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "relu - fitting estimator - predicting=close epochs=20 batch=10 test_size=0.1 seed=7\n"
     ]
    }
   ],
   "source": [
    "print(\n",
    "    f'relu - fitting estimator - '\n",
    "    f'predicting={predict_feature} '\n",
    "    f'epochs={use_epochs} '\n",
    "    f'batch={use_batch_size} '\n",
    "    f'test_size={use_test_size} '\n",
    "    f'seed={use_seed}')\n",
    "\n",
    "relu_history = dnn_relu_estimator.fit(\n",
    "    x_train,\n",
    "    y_train,\n",
    "    validation_data=(\n",
    "        x_train,\n",
    "        y_train),\n",
    "    epochs=use_epochs,\n",
    "    batch_size=use_batch_size,\n",
    "    shuffle=use_shuffle,\n",
    "    verbose=relu_fit_verbose)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fit the Test Sigmoid DNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sigmoid - fitting estimator - predicting=close epochs=20 batch=10 test_size=0.1 seed=7\n"
     ]
    }
   ],
   "source": [
    "print(\n",
    "    f'sigmoid - fitting estimator - '\n",
    "    f'predicting={predict_feature} '\n",
    "    f'epochs={use_epochs} '\n",
    "    f'batch={use_batch_size} '\n",
    "    f'test_size={use_test_size} '\n",
    "    f'seed={use_seed}')\n",
    "\n",
    "sigmoid_history = dnn_sigmoid_estimator.fit(\n",
    "    x_train,\n",
    "    y_train,\n",
    "    validation_data=(\n",
    "        x_train,\n",
    "        y_train),\n",
    "    epochs=use_epochs,\n",
    "    batch_size=use_batch_size,\n",
    "    shuffle=use_shuffle,\n",
    "    verbose=sigmoid_fit_verbose)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Determine Errors (MSE + MAE + MAPE + CP)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Determine Control Errors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x648 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_res = plot_fit_history.plot_dnn_fit_history(\n",
    "    df=control_history.history,\n",
    "    title=(\n",
    "        f'Control DNN Errors Over Training Epochs\\n'\n",
    "        f'Training Data: s3://{s3_bucket}/{s3_key}\\n'\n",
    "        f'Created: {created_on}'),\n",
    "    red='mean_squared_error',\n",
    "    blue='mean_absolute_error',\n",
    "    green='acc',  # accuracy\n",
    "    orange='cosine_proximity')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Determine ReLU Errors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnwAAAKCCAYAAABLdQQ/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xd4j9f/+PFn9h4ySNTeoxJbiVmt1BalAzFqzxqttFQJRdCiQVFbrFCSWLXFJsSuUSQhQyJ7yM77/P7IL/fXW7aVj/Q8rqvX1Xudc+5z3+n79Jz7nJeGEEIgSZIkSZIklVqaJV0ASZIkSZIk6e2SDT5JkiRJkqRSTjb4JEmSJEmSSjnZ4JMkSZIkSSrlZINPkiRJkiSplJMNPkmSJEmSpFJOu6QLIEmlzblz51i4cCH37t2jWbNmCCGIjIzE3t4eV1dXDA0NC7z+/v37zJgxgxs3bmBnZ8f8+fOpUaOGcnzPnj38+eefhISE0Lx5c9avXw/Avn37WLFiBQCjRo2iV69eaul6e3uzatUqQkJCaNSoEVlZWWRlZdGnTx/69u2rnDd69GguX75Mq1atcHd3V/YvX76cPXv2YGJiwrhx45R9Dx8+5K+//qJu3boAhIWF4eLiwt27d2nWrBkrV67MdY+DBg3i6tWrlC9fnrJlyyr7AwIC8PT0pEKFCkWq63dFpVKxfv16jh49iq6uLqmpqXz88ccMHz4cbe23/5/Rpk2bKvV79+5dTExM1OrIw8Oj2GmmpaXRqVMnDh06hIGBQaHnr169mszMTMaOHVvsvApTUu/D8uXL2b59O1999RXjx49/K3lI0v8MIUnSG3fx4kVRq1YtkZGRIYQQIi4uTrRs2VK4u7sX6frg4GBRq1YtERQUlOfx3bt3izZt2uS5f/fu3fmm+/J1YWFhwsnJSfz8889q5w0YMEDUrVtXHD58WG2/u7u7uHjxorJ98eJFUbduXdGrVy/lXl9MoyAdOnQQO3fuVNvn4uIigoODC7yuJPz0009i8uTJIi0tTQghRFpampg4caL47rvv3kn+L9blgAEDxOLFi/M8Vlzx8fFFPjctLU2kpqa+cl6FKan3wcXFpch/l5L0PpNDupL0DpiZmdG0aVNu375d0kVRY2try9y5c/H09OTy5ctqx4YOHYqrqytxcXEFptGnTx9CQ0NZs2bNa5dnyJAhWFlZvXY6b9KVK1fYu3cvs2bNQldXFwBdXV1mzZrF4cOHuXTp0lsvw+TJk1/pWGFMTU2LfK6uri56enqvnNer+F98HyTpfSWHdCXpHcnMzKRcuXLK9pMnT5g1axbp6emoVCq+++47Gjdu/M7LVbduXerUqcOhQ4do1qyZsn/8+PGcPHmSuXPnsmjRonyvt7a25qeffmL69Ol8+umnasPPxeHs7KwMTR4/fpxFixZhZWVFgwYN8Pf3Jyoqit69e7N9+3Y+++wz4uLiuH37No0aNcLNzQ1vb2+2bduGjo4OZcqUYdasWVhZWSnDdi9fM3z4cFxdXYHsZ9OnTx969+6dq1x///03dnZ2mJiYqO03MzPDzs6OI0eOcPnyZVatWkWNGjVYvHgxKpWKb7/9lqysLDw8PNDU1GTmzJnExsaSlZXFsGHD+OSTT7h58yYzZswgMTGRfv36cerUKS5fvsy9e/fU8mrUqFG+9daoUaN873HSpEn88ssvJCUlkZKSgoODgzJ0OWXKFI4cOcLatWtp1KgRQ4cOxc/Pj59//hlfX18CAwNxcXHh008/5dy5c8yZMwdra2s8PDzw9PRk9erV2NvbY2Jiwq1bt5S6zmkU7t69mw0bNmBpaUnHjh2ZO3cu9vb2LF26lPLlyxfrfcjJr169eujp6RESEoKWlhYLFiygYsWKANy8eZOFCxcihEBDQ4OpU6diZ2cHQHR0NK6urkRHR5OZmYm9vT2TJ09GX18fgNjYWL7//nvu3r1L/fr1WbBgAQCPHj0q0jsiSe+Fku5ilKTS6OUh3dDQUDFq1CgRHh4uhBAiIyNDfPbZZ2LXrl1CCCHu3r0rmjdvLhITE4UQ725IN8eYMWPEsGHDlO2cYcJbt26JevXqiZMnTwoh8h7SzRkOGzNmjOjbt6/IyspSSyM/HTp0EJ06dRIDBgwQAwYMEI6OjrnKamdnJx4+fCiEEMLNzU0IkT0E161bN5GcnCwSEhLEihUrxOXLl8VHH30koqOjhRBCrFixQgwcOFBJK69rJkyYIA4cOCCEEOLZs2di6NCheZZz6NChYvLkyXkemzx5slJvY8eOFStXrlSOzZs3TwQGBgohhBg8eLBYunSpEEKIiIgI0bx5c2Wo8uLFi6J+/fri3LlzaveZn5eHdAu6x8DAQOHr66t27fnz55XtDh06qD3PWrVqiT///FMIIcSBAwdEp06dlGO7d+9We6bu7u6idevWIi4uTmRlZYmuXbuKffv2CSGE+Pfff4WdnZ148uSJEEKIzZs3i1q1ahU4PFvY++Du7i6aNGkiIiIihBBCrFy5Unz55ZdCCCESEhJE8+bNlXu5fPmyaN68uTJkPWTIELFs2TIhRPbQdK9evZSyuLi4iJ49eypD1s2bNxdXr14VQogivyOS9D6QQ7qS9BYNHjyYzz//nM6dO+Pg4KD08N24cYPg4GB69uwJQJ06dShXrhy+vr6vnaeGhkaxr1GpVHnu//DDDxk+fDgzZ84kKSmpwDRcXV15/PgxGzduLHK+w4YNw8PDAw8PD6ytrXMdr1q1KtWrVwfAxcVF2d+yZUsMDAwwMTFhzJgxeHt70759eywsLAD4/PPPuXjxImFhYfleY2ZmxqFDhwgJCcHa2pply5YVudx56dWrF97e3gBkZWUREhJClSpViIiI4Pz58/Tp0weAsmXL0rhxYw4cOKBca2BgQKtWrXLdZ3G9fI+2trZcvHiRr776CmdnZwICAgr9rKBNmzYA1K5dm9DQ0ALPtbe3x8zMDE1NTWrWrElISAgAhw8fpmHDhkrvW/fu3YtU/sLeh2bNmimTOnr27Mm1a9cICwvj5MmTGBsb06JFCyB7kouZmRknTpwgIiKCc+fOKT1zurq6zJs3T3lXAFq0aKEMWVepUkW5jzf9jkhSSZINPkl6izZu3Mju3bsZMGAACxcuJDo6GoCIiAgAvvnmG5ydnXF2diY9PZ3ExMQipaurq0tGRkau/enp6cp3ZsURGhpK5cqV8zw2duxYzMzMcHNzKzANKysrZs6cye+//87jx4+LXYa8Zpq+PIya3/7w8HC1H/AyZcoo+/O7Ztq0adSpU4dBgwbx9ddfc/369TzzqlSpEs+ePcvzWEREhFJv7dq1IzY2lhs3bnD27FkcHBzUyuDi4qI86+DgYJKTkwu9z+J6OZ0///yTy5cvs3HjRjw8PGjTpg2pqakFpmFsbAyAnp5enu9YXue+fP6zZ8+UZwBgbm5erPuAvN8HMzOzXGlGRkbmev4AFhYWhIeHK/X/4vG6deuqzZZ/8T5e/Nsq6jsiSe8D2eCTpHdg3LhxGBkZsWPHDgBsbGzQ0dFRejM8PDzYs2cPTk5OBaazb98+5frY2NhcvW4hISHY2NgUq2z//PMP9+/fp1OnTnke19HRYcGCBXh7e3Px4sUC0+rSpQvt2rVj+vTpxSpDjlu3bpGSklLs62xtbYmJiVG2Y2NjAQqsi4SEBMaMGcOxY8f48ssvGT16tFojLEfnzp25efNmrrpOSEjg5s2bdO7cGciup65du+Ll5cXBgwfp2rWrWhnc3d2VZ717925GjBhR7Pssrps3b9KsWTPlW7XCGnBvStmyZfN8HsX18vvw4gSinDStra1zPX+AmJgYbGxslPp/8XhwcDDx8fGF5l/Ud0SS3geywSdJ74CBgQEDBw5k+/btZGRkYG9vj62tLUeOHAFQ1jcLCgoqMJ2dO3cC2UNp1tbWbNiwQTkWHh6On5+f8qF6UTx9+pQZM2bwxRdf0Lx583zPq1u3LqNGjeLKlSuFpjlr1iwePXpU5DK8aOvWrUovaHE4OTlx+vRp5Ufdy8uLjz76qMDJAT/++CNRUVFoaGjQrFkzMjMz8xwOb9asGT169MDV1ZX09HQguyfV1dWVnj170qRJE+XcXr16cfDgQVQqldIbVa5cORwcHPDx8VHOmzlz5juZ3Vu5cmVu3bqFSqUiOTmZq1evvvU8ARwdHbl+/TrBwcFA9sSXV/Hy+3Dt2jWlt9Xb25tGjRpRvnx5OnTowPPnz5WZ5v7+/sTHx/Pxxx8r9b9nzx4g+9l9++23RWr8FvUdkaT3gZylK0lvWM7Cy5D9Dd+sWbOoUaMGAwYMYO3atXz55ZdMmzaNVatW4erqyubNm1GpVPTu3Zs6derw6NEjZfh0zpw5eS7UrKOjw8qVK5k/fz4HDx7E3NwcAwMDfvrpJ3R0dPIsl7e3N3/++ScxMTE4OzsrCy9/8cUXfPnll8p5o0eP5u7duzg7O7NgwQKl0TRq1ChOnDihnHf06FGWL19OYmIiGhoaymLMFhYWuLq6FrgY8MSJE4mJiWH79u2cOXNG2Z/zfdmFCxf4888/iYqK4ptvvlEWl96wYQNnzpxBT0+PlJQUpk6dCkDjxo2ZOnUqo0aNUmbp/vbbbwVe061bN8aNG4euri5JSUksXLgw3wWIXV1dWbNmDQMGDEBPT4+0tDQ++eQThg0bpnaenZ0dlpaWODo6qu1ftGgRrq6uHD16FIC2bdvy8ccf8/DhQ+bNm0dkZCTOzs4sW7aswOHPqVOncvfuXUJCQjA3N2fIkCEF3uPIkSOZPHkyTk5O1KhRgwoVKuDl5UWVKlXw9fUlMjKSefPmMXfuXBYvXgxkL/Oybt06ZbmXb775hqFDhyrPY86cOTRs2BAvLy/S0tLYtm0bWlpaSv5VqlShe/fuzJw5k1GjRmFtba30dubXWCrsfcjRsmVLFi9eTGBgIFpaWsrscWNjY9auXcuCBQtQqVRoaGiwZs0aZdmZnPrv378/WVlZjBgxAisrK7V6q1OnDvfv3+fu3btERkZia2tbrHdEkv7XaQghREkXQpIkSSpd4uLilMZrTEwMrVq14tq1a6/cYFq2bBmhoaGFfksqSVLe5JCuJEmS9EZlZmYyevRoZfa3j48PTZo0kb1jklSC5JCuJEmS9EZpaWlRsWJFvvzyS7S1tTE0NFQWM34Vnp6eyhDyypUrGT169BssrST9N8ghXUmSJEmSpFJODulKkiRJkiSVcrLBJ713PvvsM2UBWwcHB1q1aqVsf/bZZ6+cbvfu3Yu8YPC+ffteea25wkyZMoWmTZvSoUMHnJ2d6dOnD+PHj+fu3btvJb/XsX//fr755hsGDx5Mt27dWLJkCYUNGpw+fVqZAZrXdl5mzZpF06ZNlaU1XkdhaV25coVvvvnmtfN5Ux49eqQ2izovy5cvx8HB4b2IBFHc+h0+fPhbX8ImPT2d2bNn88UXX+Ds7MxXX32Fm5sbaWlpAAwaNIgGDRrg6OiIs7Mz3bt3Z+LEicTGxjJnzhwaNGhA+/btlUgriYmJ9OnTh7Zt2yprZ75o1apV/PLLL2/1niQplxIN7CZJr+DFeJ4uLi5iypQpeR4rrpy4m0WRmZkpkpKSXjmvwrwcL/Xw4cOiSZMmanFPC+Lu7i5cXFzeVvEUAwYMUGLdxsTEiObNmyuxR/MzZ84csWfPnny3C8qroDjBxVFQWiqVSiQkJBSaxsuxZd+WDRs2KHFgC+Li4qLENX5bXo69+yqKWr85EhMThUqleq08C7Ns2TIxceJEJQ70s2fPhIODgxKbWYjse9+5c6cQQoj09HQxYMAAJcaym5ub+OSTT0RaWppy/u+//y6uXLmSZ35paWkiOTn5bd2OJOVJ9vBJ752CeoMK6ykqSM6aXUWhpaWFkZHRK+dVXJ06daJ3797MmDEj37i3JWH69OlKrNsyZcpQoUKFQuOvnj17VonXmtd2SdPQ0Hhjoc7ehDNnztC2bduSLsYbU9z6NTY2fuuLHd+8eZOmTZuiqZn9k2htbc3o0aPzDVOoo6NDp06dOHv2LJC9RmV8fDzbtm0DskPLBQcHqy3K/SJdXV05Y1l65+QsXem906hRowKPeXp6snr1auzt7TEyMuLWrVuYmpqyatUqZs2aRVRUFGlpadSsWZMZM2agra2Nm5sbf/31F9OmTaN3796MGzeOU6dOMX78eK5fv86DBw8YPHgw/fv35/79+0ydOpXExEROnDjB8ePHWbRoEVZWVtjb23P58mU0NTVZsWIFlpaWAJw6dYpff/0VMzMzmjRpwr59+zAxMWHOnDlFjozRu3dvNm3axJ07d/jwww/x9PTkwIEDyo/hjBkzqFGjBgcPHlRmNDo7O9OqVStGjx7N8uXL8fPzA7Ijf8yePZty5coVmq9KpcLV1ZV///0XTU1NqlSpwvTp0zE0NKROnTrKeVevXiUiIqLAYfXg4GAMDQ2xsrLKtf38+fN8n09edu/ezYYNG7C0tKRjx47MnTsXe3t7li5diq2tLevWrePIkSNoaWkpZX4xZuqTJ0+YMGEC9+/fx9HRkcmTJxMTE8OoUaO4ceMG9+/fB7JniO7evRsDAwP09fWZOnUq0dHRykLEzs7O1KpVixkzZhAVFYWrqysxMTFkZGTw9ddf4+TkRFhYGBMnTuTGjRvMnz+f/fv34+fnR9OmTblw4QLt27dn9erVeHt78+uvv9K4cWPc3d1JSUnh4cOHfPjhh0D2cHRgYCAqlQpra2tmz56tdk8vKuyd8/b2Ztu2bcpC1bNmzVKeS15+/PFHZaFmU1NTXFxcWLVqFadOneLbb7/lypUrXL9+nalTp1KpUiVWrlxJVlYWqampDBs2jE8++SRX/d68eZMZM2aQmJhIv3798PX1JT4+Hnd3d6pWrcratWvZsGEDX331FePHj2fWrFns37+fAQMGEBAQoPbsALKysnBzc+PixYuULVsWe3t71qxZQ7t27Vi+fHm+91a+fHl2797Nxx9/jK2tLQD9+/fP93zIXnom5900MzNj1KhRrFy5EicnJ/744498ZxIfP36chQsXYmtry8aNG8nKylKi02hoaFC1alWmT5+OgYEBz549w9XVlbi4ODIyMujfvz89e/YkODiYyZMn888//zB79mz27dtHREQECxYswN7evsByS/9hJd3FKEmv4+Uh3Rzu7u6iVatWIjo6WmRlZYmFCxeK2NhY4e3trXZtzhCNELmH+Tp06CBmzpwphBDixo0bomHDhiIjI0MIIcTFixdFhw4dlHN3794t7O3txZMnT4QQQgwbNkysWrVKCCFEdHS0aNiwobh69aoQQohjx46J2rVrFzg09vKQrhBCJCQkiFq1ailDptu3b1eGkC5evCi+/vprtft/eUh38+bNytDY7t27xXfffaccW79+vRg1alSeZfH19RVDhw5VtseMGSOCg4OV7ejoaNGjRw/RokULceLECbVre/ToIf7++29le8uWLeK3337Lc7s4z+fff/8VdnZ2Sn1v3rxZ1KpVSymXl5eX6NKlizJsNm3aNPHjjz+qpTVixAihUqlERESEqFevnggPDxdCCBEcHCxq1aolhBAiKSlJNG/eXKnnjRs3KmXIa0h30KBByrBqdHS0cHBwEJcvX1ZL18vLS6nzsLAw0bx5c+Hv76+kMXLkSOU5+fr6KsOGQgixadMm5d/d3d3FkiVL1OrrxbwLeucuX74sPvroI2XIcsWKFWLgwIGiMHkN6Xbo0EH88MMPQojs9/DkyZPC19dXBAUFCSGyh2Rbt26tDOO+WL8519SvX1+pp5kzZ4oZM2bkeV9CZD+74cOH5/nstmzZIrp37y5SU1OFSqUS48ePV/s7zU9YWJjo1q2bqFevnhg5cqTYu3evSE9Pz3WfOe9jQkKC6NGjh5g1a5ZyPC0tTXTo0EGMHj1auLq6Fpjfzp07xaBBg4QQ2c9m5MiRyrGRI0eKp0+fKve6YsUKIYQQUVFRomXLlsozDQoKErVr1xaHDh0SQgixcuVKMXz48ELvVfrvkj18UqnVsGFDLCwsAPj+++8RQhAWFsbXX3+NtrY2oaGh6Ovr07dv33zTyBlqrF27NsnJyURHR+fbK1a1alUqVqyonB8SEgJk97RYWloqPZMdO3bMM1xaYV4eyq1RowajRo0iNTWVzMxMpUcqP7a2tgwcOBCVSkVSUpJaLFFra2sqVaqU53Wmpqb8+++/nDt3Tglt9WL4NgsLC3x8fAgODmbIkCFkZWXxySefAFCtWjXlGUD28OSL4che3DYzMyvy8zl8+DANGzZU6rt79+5qH8H7+PjQuXNnZdisd+/eDBo0iDlz5qClpQWAg4MDGhoalC1bljJlyhAaGprr2eac6+3tTffu3enfv3++Q+oRERFcuHCBefPmKfXSvn17du/eTdOmTZXzOnbsCKCERevatSve3t40btyYO3fuULt2baXX9syZM2rD3Xp6evTr1w9NTU2ioqKU+39ZYe+ct7c37du3V57N559/zu+//05YWFiB8Yfzk3NPLVq0ACAsLIxff/2VsLAwdHR0iIuLIzAwMN/ebENDQ6WOateurYSgy0/r1q2VZ2dubq48u0OHDuHo6Iienh6QHT7v5fBsebG1tcXHx4fTp0+zd+9epk2bxoYNG9iyZYtava1du5a9e/eSkpJCq1at+Pbbb5Vjurq6jB07lmnTpqmFhyuMmZkZ9+7d48KFC3z00Uf8/vvv6OrqEhoaip+fH7/++isAlpaWtGvXjj179ijPVQihDPfXrl2bvXv3Fjlf6b9HfsMnlVovfyfk5eWFp6cnK1euxMPDAycnJ1JTUwtMI2e4LOcHpKCA6y8Orenp6SnnRkZGUqZMGbVzC4qXmp+cb+MqV65MYmIiI0eO5IsvvmDbtm0sXry4wHsJCgpi4sSJfP/992zdupVp06apnd+tWzd+/PHHPK9t1KgRc+bMYc2aNXTo0IF169blORO3YsWKODk5sW7dOmXfkiVLaN68OZA9E/LOnTs0bNgwz+3iPJ9nz56p1enL9RkeHq7W0LSwsCAjI4OoqChl34vPS1dXN89nq6+vz5YtW/Dz86Njx478/PPPJCUl5Vmm8PBwJa8X842IiFA77+X3slevXhw6dIj09HR8fHzo0aOHcuzFBt+lS5dwc3Nj4cKFbNmyhREjRuRbP4W9cy/XT865OfdQXC/fk4uLC2XKlGHHjh14eHhgbW1NSkpKvtfn97dT3PNfvm8zM7Mi34Ompibt27dn8eLFHDt2jJiYGA4ePKh2zrBhw/Dw8OCvv/7CxcUFfX19teMVKlQA1N+BwjRt2pSZM2eycuVKOnTowMaNG1GpVHm+T2XKlFF7RlpaWsr/1BSl3qT/Ntngk/4zbt68iZ2dnfLDl5mZ+U7ytba2JiYmRm1fXFxcsdPZs2cPlSpVom7dugQGBpKUlKQ0Bgq7lzt37mBkZKT0sBTn3hMTE2nevDkbN27Ew8MDb29vZfkJT09PtXMNDQ3z/WH39/fH3t5e+e7p5e3iPJ+yZcuq1WlsbKzacVtbW7XjMTEx6OjoFPiNWl4yMjKwtLTk119/5fDhw8THx+cbMcLGxkbJ68V8C/tO0s7ODktLS44ePUpQUJAyCSY4OBgjIyPlO9CbN29StWpVpVFRUP0U9s69XD859ZdzD6/r5s2btG7dWtl+Vw2Rl++7qH9nixYtUmvIlytXDnt7+3wb929SYmIiLVu2ZPPmzWzcuJFdu3axb98+5VvCl5/Tm3pG0n+PbPBJ/xmVK1fm3r17pKenk5mZyYULF95Jvu3atSMmJgZ/f38g+6PtnPW9iurIkSN4eXkxe/ZsNDU1KV++PNra2ty8eRMg1xCSkZERKSkpCCEYO3YslStXJiEhgcDAwDzP379/P/Pnz88z76NHjyoNu0qVKlGuXDllWHP58uXKD1JycjL79++nZcuWyrWTJk1SJoqcPn1abbbpy9vFeT6Ojo5cv36d4OBgAP7++2+1405OThw6dEjpAfP29qZHjx7KEG1RRUREMGPGDCC7F6tu3bpkZWUB/1fHAOPHj8fS0hIHBwdlfb/Y2Fh8fX35/PPPC82nZ8+ezJ8/HwcHB2Xf6dOn1YZzK1euzJMnT5TGWc4M0bwU9s45OTlx+vRp5dl5eXnx0UcfFTqca2RkRGpqKhcvXmTTpk35nlepUiVu3LgBwL1794iMjCww3Telc+fOHD58mLS0NIQQHDp0qEjXRUdH89dffynbkZGRXLt2Ld9ZtsV17tw5pkyZkuexQ4cOKXlXqVJF+fsqX748LVq0wMvLC8hu+J06dYrevXu/kTJJ/z1as2bNmlXShZCkV7Fw4UKOHDlCcHAw0dHRyo/lvn372LBhgzKL79NPPwWyv3Hx9/dn5cqVXLlyBQMDA/z8/NDU1OTw4cOcPn2au3fvUqFCBf744w9u3LjB7du3ad26NdOnTycgIIAbN25QuXJl5s2bR2hoKPfu3cPc3JzFixfz5MkTUlNTSUpK4s8//yQgIABNTU1atWpF3bp1mTdvHn///TfGxsYEBgby6aef8sEHH+S6rylTpnDlyhWCgoI4fvw4W7duJSwsjHnz5tG4cWMguyfNwsKCRYsWcf78eTQ0NLhx4wbXrl2jZ8+eWFhY4OHhwd69e3FwcOCzzz4jMzOTRYsWcfHiRXR1dfH39ycoKIhPP/2UM2fOcPfuXbp165arPHp6emzfvp1du3axdetWqlevzsiRI9HS0kIIwbJly/Dx8WHbtm00adKESZMmKd/4rVixAjs7O2rUqMGCBQsYN26cMhz38nZBz8fHx4fz588rz6dJkyaULVuWOXPmcPToUerUqcOJEycYPHgwpqam1K5dm5SUFH777Tf27NmDqakp06dPR1dXl4ULF3Lq1Cnu3r1L/fr1Wb16NVeuXOH27dtUr16dmTNnEhERgZ+fH1988QV+fn6sXbsWLy8vIiMjmT59OiYmJlhbW+Pl5YW3tzfVqlWjffv2tG7dmj179rBlyxZ8fHwYMWIEHTt2JC4ujnHjxinp2tnZqQ3VlS9fnjVr1jBv3jzlm7EVK1bg5OSkNMKqVq3KkydPWLp0KX5+fhgYGHD58mXi4uK4du0aBw4c4MFHvnQmAAAgAElEQVSDB8r3cAW9c7a2tlhZWTF//ny8vb1JTExk/vz5hX5bqlKpWLVqFf7+/gwePJgFCxYofyfGxsbUrl1beZZr1qzh8OHDPHv2jLCwMPz9/XPVb4MGDZgxYwahoaGEh4djaWmJm5sbT548IS4ujrt37+Lj46Pc14EDB/J9ds2aNcPBwYGgoCAWL16Mr68v9vb23L59m0GDBhV4X8bGxhw4cIBt27bh5eWFj48PI0eOpF27dkD2wsuPHj3iwYMHPHv2jFatWuVK4/Tp0yxcuJCoqCguX75MmzZtlKWbbt68ycmTJ5UFtO/cucODBw/o1asX+vr6bN26lb/++ott27ZRs2ZNRowYgZaWFm3atGHnzp1s3bqVvXv3Mnr0aNq3b09MTAwTJkwgPDyc+/fv06BBA6ZNm0ZoaChPnjxRvqGVJDUlOWNEkv4rYmNj1bYbNmyoLFj8X/D06VPRrVu3fLdfxYt1Gh0dLWrXrv3eLmYbHx8vxo4dq2ynpaWJNm3aKLPCX8V/8Z1LTU1VewcOHjwo+vTpU4Ilypunp6cYMmRISRdD+o+RQ7qS9A6MHTtWGVI7cuQIlpaWVK5cuYRL9e7Y2NiohZh6ebu4MjMzGT16tDK07OPjQ5MmTd67xWxPnTpFTEwM+/fvp0uXLsp+XV1dTp8+ne8ahEXxX3zn/P39+eOPP4Ds3sj9+/erfUtYkrKyspSJUYGBgfnOipekt0UuyyJJ70DDhg3p168f+vr6aGhosGzZstf6Mf+v09LSomLFinz55Zdoa2tjaGiY72SK/2VPnjxh/vz5VKlSpcCFgV/Fq7xzkZGReUarsbKyYsmSJW+0fG9DpUqVWLt2Lf379yc9PZ26desycuRIAObOncu9e/dyXTNt2jTq1q371sumoaFBSEgI/fr1Q0NDQ1luRZLeFQ0hCol0LkmSJEmSJL3X5JCuJEmSJElSKSfHlCSpFPPz82PlypVkZmaSlZWFnp4ePXr0oGvXrvkGhi8pc+bMwcfHR4lnXJiQkBBWrFhBaGgoqampVKhQgZ9++klt9uv69evZv38/AF26dFGL8gHZy7W4urqyb98+ZX07yI5gsG7dOo4dO0ZKSgq1atXC1dU131msaWlpzJw5k4CAADIzM5k8ebLat2Pp6eksXryYo0ePcvz48QLva8+ePXh7eyOE4Pnz5wwdOpSuXbsqx48fP86KFSswMDAgNTWVCRMmKLNJ8xIZGYmLiwtly5bFzc1N7djVq1dZsGAB2traJCcn4+zsnG/dh4SEMHDgQLWZ5Y6OjgwYMECps4ULF+Ln54cQgoEDB9KrV698y+Xg4EC1atWU7caNGzNp0iSlDjZt2oSpqaly/Ntvv1WLWCJJUjGV5IwRSZLenlOnTon27dsrMU2FyI7NWq9ePXHnzp23kufLcU+L6+V4xgVxd3cX8+bNE0IIoVKpxJQpU8SYMWOU46dOnRKOjo4iNTVVpKamCkdHR3Hy5Enl+KJFi8SyZcvUYvDmeDEWr0qlEqNHj1biKudl0aJFYurUqUIIIQICAkSzZs1EZGSkcvybb74Rbm5uRYrr2rhxYxEWFiaEyI4Z3KBBA3H79m0hhBAxMTGiQYMG4uzZs0IIIc6fPy/s7e1zzcjN8eTJEzF48GAxadKkXLGVVSqVaNWqlfD09BRCCBEYGCjq168vHjx4kGdawcHBBT7bbdu2CWdnZ5GVlSWio6NFy5Ytxd27d/M9/+XyvGj37t0FxpqWJKn45JCuJJVCKpUKV1dXRo0apTYzs127djg6OpZgyd6cevXq0b9/fyD7g/iuXbty/vx55binpyfdunVDT08PPT09unfvzo4dO5TjAwYMYNy4cXmm7e3tTZcuXTAwMEBDQ4M+ffrg4+NDenp6rnNVKhW7du2iT58+QPZ6eXXr1lWLazp37lzat29fpPsaP368EmWhZs2a1KhRQ1mEOjg4mLS0NCUcXaNGjUhJSVEW1H6ZkZERq1atomrVqrmOxcbGEhUVpaRVpUoVTE1N85zYUBSenp707t0bTU1NJY7wrl27XiktSZLePDmkK0ml0D///ENISIha5IYc8+bNQ0dHh+PHj7No0SKsrKxo0KAB/v7+REVFceLECW7fvs38+fPR0NBAS0uLn3/+WQn5tXz5ciV6hoGBAbNnz6ZcuXJs2rSJM2fOoKenh5+fHz169KBv374FpnXr1i1mzpyJnp4eDRo0yDNGb346duyotp2WlqYWR/XWrVtqQ6E1atRg+/btynZBIaoiIiLU0rKysiI5OZnHjx9Ts2ZNtXODg4OJi4tTG56sUaMGt2/fVsvr8ePHRbqvwYMHq22np6crw9Q1a9bkgw8+4MSJE3Tv3p0TJ05gbGyslveLCorpamFhQYMGDThx4gS1atXixo0bJCQkUL9+/XyvyVlwOT09HXt7e8aPH4+hoSHp6encv38/Vx0cPnw437QePXrEsGHDeP78OTVq1GDSpElq5fX09GTZsmVoaGjw2WefKY17SZJejezhk6RSKCfkWF5xXPX19dHS0qJjx46MGDGCW7du0adPH3bu3ImjoyOJiYkMGzaMcePGsWXLFoYMGcKYMWOUNe/MzMzYtGkTmzdvxtHRUVleYtCgQbRp0wYnJyc8PDzo27dvgWmlp6czbtw4vvnmG7Zv346Tk5MSjitHz549ixwey9fXl379+inb0dHRmJiYKNumpqZER0cXKS0bGxsiIiKU7ZzQYPHx8bnOjYqKAlDLy8TEpMh5FSSnMdmpUycgu4H9xx9/sHTpUjp37syCBQtYu3YtZmZmr5T+8uXLOXjwII6OjowcOZLff/9d6Q0MDw+nZcuWhIeHA9kRV+rWrcuff/7Jpk2biIiIwMXFBcjuLVSpVErUFFCvg7S0NNq0aaOEAoTsBuHSpUvZtm0bxsbGDB8+XGnw54Sp8/DwYOnSpWzduhUPD49XukdJkrLJBp8k/cdVrVpV6XFzcXHh5MmTGBoaKjFx27dvT1RUlNIYs7W1ZeDAgfTv359Nmzbxzz//5Jt2QWldv36d6OhoOnfuDEDdunWpUqWK2vXVqlUrsJcqx9WrV3ny5EmuEFoaGhpFq4SXODk5sW/fPmJiYkhPT2fnzp1AdqOnqIrTW5nf9XPnzmX27NlKQyomJoZhw4bh6urK33//zdy5c5kxYwZJSUnFTj89PZ1hw4bRv39/Dh8+zMaNG3FzcyMsLAzI/h+DatWqoa+vD4C1tTUuLi7o6uqio6PD2LFjOXLkiNLghdz1nVMH2traVK9eXa1BOH/+fIyNjdHQ0GD8+PHcuXNHaRC2a9eOzz//HA0NDSwtLRkwYADbtm0r9j1KkvR/5JCuJJVCOav4R0REqM0+zcuLPVOQ3bMTHx+Ps7Ozss/CwoK4uDiCgoKYOHEi27Ztw87OjkuXLinRA/JSUFrJycmYmpqipaWlHDM3N1e7viiL/YaGhvLbb7/h7u6uxPDNySchIUHZTkhIKFLjEaBHjx4kJiYyduxYdHV16dmzJ76+vnzwwQfs2bNHCWjv5OSkxDdOTEzE0tIy178X5PTp06xZswaANm3aMGLECOXYkiVLaNGiBR9//LGy79ChQ5iamiozgFu3bo2Ghgb79+/nq6++KtK95bhw4QKhoaF88cUXANSpU4fq1auzfft2pkyZgrm5OVu3bs33+pzvDMPCwqhTpw6ampokJiYqx1+sAy0tLTZu3JhvWoaGhpiZmREaGoq9vX2u4+XLl1caopIkvRrZ4JOkUqhevXpUqVKFc+fOKQHbc0ybNo3+/fvn+62Wra0tNjY2akNoSUlJ6OrqcuzYMYyMjLCzswOyQ5wVpKC0rl+/TkJCApmZmUoEiLi4uGLdZ0xMDFOnTsXNzQ0rKyvCwsKwsrJCV1eXBg0aqE1mePjwIQ0aNChy2v3791e+G7ty5Qq1atXCwsKC3r17qy1dolKpMDc3JzAwUGngPHz4sMClUnK0bduWtm3b5tq/efNmMjIyGDJkCABBQUFUqVKFjIyMXNEytLW1X6mHLyMjA01NTbVeuYLSOnDgAI0aNaJ8+fIAynBt2bJl0dXVpVatWgQEBCjvRkH1feHCBYyNjZXj6enpJCQkULZsWQDWrFnD8OHDlfOjoqKUY5IkvRo5pCtJpZCmpiazZ89m9erVapMFdu/ezb///ltgKKkOHToQGxurDK8lJyczcOBAkpKSqFy5MgkJCUpD6syZM2rXGhkZkZKSQnJyMlOmTCkwrYYNG2JpacnBgwcBuHv3Lo8ePVJLb9KkScoEkZc9f/6cCRMmMGHCBCwsLHj+/Dk7duzg2bNnAHz11VccOHCAtLQ00tLSitULdvDgQXbv3g1kN0ZWrVrF6NGj8zxXU1OTvn37KucHBQVx7949unfvXqS8XnbgwAEuX77M2LFjef78Oc+fP2fVqlUAtGjRgoCAAO7fvw/AvXv3ePDgAc2bNy92Pg0bNkSlUnHq1Ckguzf44sWLfPTRR0D2d3n9+/dXGuEBAQHs2bNHuX7Tpk20aNFCmfzy1Vdf4eXlhRCC2NhYTp06Rd++fYHsOLKDBw8mICAAgKdPn7J9+3ZlyHfLli1UrFhR6d07ffq08txTUlLw9PSkZ8+exb5HSZL+jwytJkml2JUrV3B3dycrKwuVSkXVqlX57rvvsLCw4MKFC7i6uhIVFYWdnR3r169Xrrt9+zYLFixACIEQgmHDhtGhQwcAli5dyt69e6lduzbW1tZ4eXnRuXNnFi5cyLVr1/jxxx8xNjZm0KBBdO/evcC0bt68yaxZs9DV1aVmzZo8fPiQ2NhYvv/+ezp27Ej37t0ZN25cnkvJLFmyRGkIvej48ePKMHZBCy/v2rWLvXv34ufnh729PW3btlWWafHz82POnDkYGxujUqno3bt3rp7SFxW28PKcOXO4cuUKAQEBNGzYkMGDB+eaZQzZDeLmzZuTkZGhtt/JyUlZNHnfvn1s2LABfX19pQGd32LJOQ2t0NBQ0tLSqFatGgsWLFB66c6ePcvvv/+Ojo4Oz58/p2vXrsqw8tOnT3FycsLb2xsbGxv+/fdfli9frnzXaGNjw4wZM7C2tgYKXng5LS2Njh078scff2BnZ0dYWBjLli0jKCgIIQRGRkb89NNPyoSRkydPsnHjRlQqFcnJybRs2ZIJEyb8zy0WLknvE9ngkyRJkiRJKuXkkK4kSZIkSVIpJxt8kiRJkiRJpZxs8EmSJEmSJJVyssEnSZIkSZJUyskGnyRJkiRJUilXqhZejoxMLPyk12RubkhcXPJbz+d9IuskN1kn6mR95CbrJDdZJ+pkfeQm6+T/WFubFH7SC2QPnyRJkiRJUiknG3ySJEmSJEmlnGzwSZIkSZIklXKl6hs+SZIkSSrtUlKek5AQg0qlQkOjpEvzbkVEaPBfCxAmRHbMblNTCwwMjF45HdngkyRJkqT3SFxcFNbW5dHW1inpokjvSGZmBsHBj1CptKlevcYrpSGHdCVJkiTpPaKhgWzs/cfkPO8TJ44RERH+SmnIBp8kSZIkSdJ7QFtbm8jIyFe6Vjb4JEmSJEmS3gsaqFSqV7pSNvgkSZIkSZJecujQAcaNG1HSxXhj5KQNSZIkSXqPieQkSEt7vUT09NAwNH4zBSolPvusK/v3+5R0Md4Y2eCTJEmSpPeUyMpC9f1gSHnNcGMGhmi6e6KhpZXn4X37vPH03ErHjp3w979Mr16fc+PGdR4/DuSXXxZy6tQJgoOfkJGRQZs27WjcuCnLly/FyMiIyMhndOnSgw8/bMCiRfMICQmmYsXKBAY+4ocfZlCxYqVc+V29eoVTp05QpowFOjo69O8/iG3bPHj8OBAbG1uOHPmb0aMnEBQUQHDwE6ZPn8WCBXOxsrJi6NCRbNu2mcTERFJSUmjatBmtW7fDw2MjJ08ew96+EefPn2HJkhXs2rWDMmXKEBERzqBBQylbthzLli0mK0tFpUqV8693IXB3X6x27dOnT5k3bxYdO3biwYP72NqW58GDf/nggwpoamoSFRXJ5MkubN/ugY1NeeLj4xg3biL79nmzY8cW2rRpz6VL5xk/fjKNGzd9veeZB9ngkyRJkqT3lIaWFpqLNr6ZHr58GnsA3bv3wtNzK/36OdO6dTvc3X9j2bLV7Ny5HX9/P7y8/mL9+i2kp6czevRQ1q3zoEWLljRr1oLExETc3GYzd+4iBgwYzJw5P/Pddz/g63ucM2dO0a+fc678Tp/2xc6uIR07duLevTvExERz7Ngh1q/fSlpaKsePH6Ft2/bUrFmL9ev/BODTTx25ds0fgJo1a9OsWQtUKhWTJo2jdet2ODsPxstrF+PHT6JPny959OgBKlUWAwd+w40b19m8eQPdu/ciJCSYBQuW8PRpGCdOHM2zPs6dO53r2u+++wE7u4Y0atSYoUNH8vhxEPfu3SE4+AkjR47l4cMH/PGHO0OGDKdmzVosXfor586doXv3XuzYsYWBA4fQt+9XaGq+na/tZINPkiRJkt5jGobG8A6GY83Ny6Cnp4+xsTE2NrYAGBsbExoaQnp6Oh4eGwGwsrJCpVIRFRXJmjUr0dc3ID4+XkmnfPkPADA1NePRo4d55jVgwGDWrPmDXbt2MHDgN2RmZlG2bDkA9PT0MTMzL7CsGRkZrFq1HCMjYxIS4tTy1tTU5IMPKnDy5DGePn2Kh8dG0tPT0NPTIzj4Mba22eUrV84m3/SDggJzXZvjgw8qoqWlRbVq1bl37w4VKlQEoEaNmjx+HKika2NjQ1BQAA4ObShTxgJDQyMMDV99YeXCyAafJEmSJEmvTFNTC1NTU5ydBwPg63ucpKQkNm1ax44dXmRmZnLp0nnlfI0ihAd5/DiQH3/8mYSEBL77bgJubr/x7FkEAGlpqcTHZzfiDAwMSfn/w9lRUf+3XImb2xz27DmAtrY258+fzjOPKlWqkpAQj7PzYNLT07lyxQ8LC0uOHj0EoORX1Gvzu78XtytXrkpExFNMTU0JD39Ks2YfFVoXb4ps8EmSJEmSVKBLly4QERHOpUsXePDgPo8ePeD+/XucO5fdmOrYsRN//OGOgYEBNja2mJiYUKtWHX791Q1bW1siIsK5ffsW16/78+jRAx4/DuLEiaM8efKYqKgorKys1PJ79OghV674oa2tjaNjFywsLOnYsRPz58+mWrXqmJiYAGBubo6BgSEeHhtITk7mn39uER7+lE8+yT63evWaREZGcunSBZKSEomICMfX9zjt23fEwaEt169fY+PGtSQmJtKpU2dq166Dre0HLF26CCsrayIiwrl+/SoNGzZWK19e1z5+HMSjRw/YvXsno0aNIysrU6kfO7uGVKhQkTFjJrB16ybKlbNBS0ubVq1aK3W7f78P3br1fGvPUEOUoqB0kZGJbz0Pc3ND4uJe8+PYUkbWSW6yTtTJ+shN1klusk7U5Vcf4eGPsbHJf0LBf8G4cSNYvvzPki7GOxUYeA9f33M0adIUOzt7rK1NinW9XIdPkiRJkqT3xtmzp4mICOfs2byHaqW8ySFdSZIkSZJKzIMH93nw4F9l28DAgA4dPsn3/Nat29K6ddt3UTQAoqOjuHTpgtq+9u07Ymho+M7K8CbIBp8kSZIkSSWmZs3a1KxZu6SLkS9LSyu6dOle0sV4bXJIV5IkSZIkqZSTDT5JkiRJkqRSTjb4JEmSJEmSSjnZ4CuGC2GpuByLID2r1KxkI0mSJEnvhbNnTzNkSL9XujY8/CkTJozi6tUrBZ538OC+V0r/fSAbfMVQz1KXoLh0Fl6OJ6v0LF8oSZIkvceS0lVEp2S91j9J6aqSvo1CtW7dFiOjVwshZ2Nji719o0LPK80NPjlLtxjM9DRZ4mjD8L1hrLiWyPhGJkUKESNJkiRJb0OWSjD4UBTJma/XCWGorYFnN2u0NPP+Tdu3zxtPz6107NgJf//L9Or1OTduXOfx40B++WUhp06dIDj4CRkZGbRp047GjZuyfPlSjIyMiIx8RpcuPfjwwwYsWjSPkJBgKlasTGDgI374YQYVK1bKlZ+//2WOHj1E2bLl0NTUZPDgYdn3m5XJ9u1bCAl5Qtmy5Rg0aChHjx7iwYP7aGlpU6lSZTp37sbmzev/fzzfKLp160GdOvWUtG/duoGr60/89dc+Llw4y+rVf7Bx4zaOHTtMePhT1q1bTdeuPXn06AF+fhcwMDCkevUafPrpZ7nKmZaWytKlv1GhQgWePg1j1KjxXL16hV9/nc8XX3zNhQvn+PRTR7y999CwYSNiY2PR09OjV6/P+fvvA1hYWKCtrYOz82A8PDZy8uQx7O0bcf78GZYu/QNb2/Kv9VxfJBt8xVTeRIdfWpsz9XQs5nqaDKz/9gNWS5IkSVJetDQ12PiZFWmv+amRnpZGvo09gO7de+HpuZV+/Zxp3bod7u6/sWzZanbu3I6/vx9eXn+xfv0W0tPTGT16KOvWedCiRUuaNWtBYmIibm6zmTt3EQMGDGbOnJ/57rsf8PU9zpkzp+jXzzlXfkZGRowdOxETExN+/PE7nj9PwsjImMTERHr37oOenj6jRw/F0bELx48fwdn5G+rX/5B79+7w8OED7t69w/z5v5KQEM/kyeNZu3azknaDBvbY2NgC0LJla7ZuzT72ySeOeHvvZujQkahUKiZOHMOWLTvR1tZm6FBn2rfviI6Ojlo59+71plKlynz99QAOHz6Ij89u+vcfxM6d22jX7mN69+5LXFwc0dHRWFuXpUcPJx4+fMD8+bNZsmQFpqam/PjjFB49eoiz82C8vHYxfvwk+vT5EnPzMq/1TF8mG3yvoKqZDjNbmvPT2VjM9TXpUf39WnxRkiRJKj2MdTV5F10P5uZl0NPTx9jYWGkwGRsbExoaQnp6Oh4eGwGwsrL6/71rkaxZsxJ9fQPi4+OVdMqX/wAAU1MzHj16mGde+voGeHisx8TEjIiIcBISEjAyMlbKAFCunA0hIcGMGTOBdetWEx0dzahR4wkNDaFcORslj2fPIop9r3FxsaSkJLN9+xYAbG3Lk5iYgIWFpdp5jx8HkpKSgofHRhITEzA3N1eOVahQEQ0NDQwNjZRtgBo1ahIZ+QxTU1PlPoKCAqlevQbly3+ApqYmH3xQodhlLoxs8L2iD610+aG5GXMvxWOmq0m7ivolXSRJkiRJeuc0NbUwNTXF2XkwAL6+x0lKSmLTpnXs2OFFZmYmly6dV84vyqdQq1Yt4+uvB2Jv35CAgP9rFMbFxZKWloaenh4REeFUqFCR0NAQXF3nExz8hGXLljBixBiOHTsCQHx8HOXKlcuVvqGhIcnJyejo6BAfH/fCvWiSmppKeno6ZmZm9O8/EE1NTc6c8cXMzDxXOpUrV0VLS0vpyQsKCijSfVpblyUhIR5TUzPCw5/So4dToXXyurRmzZo1663n8o4kJ6e/9Tz09XVITc0AoIKJNlYGWvx+LYHaZXSwNf5vtp9frBMpm6wTdbI+cpN1kpusE3X51UdSUjzGxrkbH2/TpUsXOHr0EJUrV+HKFT+uXr1MnTr12b/fm8jICBwc2uLre5zbt2+ir69P/fofcuvWDfz9r/D4cSD+/pepV+9DLlw4y9Wrl2nYsAkHDvjw77/3aNbso1xhyoQQ/PWXJ1FRkcrM2oSEBC5dukBKSgpHjvxN7dp1aN26Hfv3+3Dz5nX++ecWLVs60KRJM0JDg7lyxY+zZ08xZMhwMjMz+euvHUREhNOmTTs0NbXw9v6LmJgY7tz5h7Jly1GpUmX8/C5y/fpVPvigIh9+aIeX1y7u379HamoqDRrY56qXGjVqcPjw3zx69IALF87x0UetCAoK4sCBvahUWXz4oR1RUVHs3LmNiIhwPvzQDgMDA2rUqMX27R7cvXsHW9vytG/fkePHj3Dq1AnKli1LlSrVcuUVFxdFUFAw5cuXp1w5G4yM9Ir1DDWEKD3TTSMjE996HubmhsTFJavt23n/OTvuPcetTRlqWejkc2XplVed/NfJOlEn6yM3WSe5yTpRl199hIc/xsamcgmUSCpJgYH38PU9R5MmTbGzs8fa2qRY18tlWd6AvrUM+ayqAT+fjyUkMbOkiyNJkiRJkqTmvzkG+YZpaGgwrIEx8Wkqpp+N5bf2FlgZaJV0sSRJkiTpf96DB/d58OBfZdvAwIAOHT4pwRLlLSQkmJs3r6vt69KlewmVpvhkg+8N0dTQYGITU2ZfiGPGuTgWti2Dia7sQJUkSZKkgtSsWZuaNWuXdDEKVaFCRWWm7ftItkjeIB1NDaa3MEdfSwPXC3GkvuZCmJIkSZIkSW+CbPC9YfraGri2MicxXYWbXxyZKtnokyRJkiSpZMkG31tgqqfJHIcyBMRn4n41gVI0EVqSJEmSpPeQbPC9JWUNtfjFoQwXn6ax4Z+kki6OJEmSJEn/YXLSxltUyVQb11bmTDubHXe3d02jki6SJEmSVMokpcSTlp7yWmno6RpgbGCW7/HAwAA2b15P1arViImJYeLE79i8eT0qlYqYmGjq129Ap06dWb58KebmZQgJecInn3SiWbOPXqtc0psjG3xvWV1LXaa1MGfOhTjMdDXpWNmgpIskSZIklRJZWZkMm9uS5NTXCzxgqG/CVtebaGnl3SzQ1dVl+PDRlC//Ab///hsPHvzL3bt3mD//VzIzMzlzxpezZ08hhApn58HExsby6NGD1yqT9GbJBt870MxGj2+bmPK7fwImupo0ty1eOBRJkiRJyouWljZrp194Iz18+TX2ILvBt2vXDkxMTAkIeMSTJ0GUK2cDgLa2Nh06fMKWLRuVfWXKlKFp0+avVSbpzZINvnekYyUD4tNUzPeLY27rMtSz1C3pIkmSJEmlgLGBWYHDsW/C1q2bqVu3Ho6OXUhOfk5MTAwREeEAZGRkcPbsKapUqYq/f3bc25iYaAICHslG3/8Q2eB7h3rXNCIuTcWs83EsamdBZWoDo+cAACAASURBVFNZ/ZIkSdL/vrZt27Np0zrCw59y585tKlasRJ06dVm3bjXJyc/p1q0XVapU5do1fzZuXEtcXBzOzoNLutjSC2SL4x0bUt+YuFQVP/3/EGxlDWUINkmSJOl/W+PGTWncuCkAgwYNzfe88eMnv6siScUkl2V5xzQ0NPi2sSnVzbWZcS6W+DRVSRdJkiRJkqRSTjb4SoCWpgY/NDfHRFeTmedjScmUjT5JkiRJkt6eEhnS9fLyIigoiNjYWIYNG0alSpWUY3PmzKFMmTI8e/aMOnXq0K9fv5Io4lunr63BzJbmTD0dy7yL8fzcyhwdTY2SLpYkSZIkSaXQO+/hS0hIYNeuXUyaNIlhw4axYMECtePVq1dn3LhxzJw5kxUrVrzr4r1TJrqazHEwJzgpkyX+CahkCDZJkiRJkt6Cd97gu3HjBtWqVQOgUqVK/PPPP2rHc3r0oqKisLGxedfFe+esDLJDsF2NSGPNzSQZd1eSJEmSpDfunQ/pxsXFYWhoqGwLIcjIyEBHR0fZd+rUKdatW8fkycWb7WNublj4Sa9JS0vzjedjbg6LHfUY//dTbM31GGhv/kbTf9veRp2872SdqJP1kZusk9xknajLrz4iIuTnP/9FGhoa6OlpY2ys90p/J++8wWdubk5ycrKyraGhodbYA2jXrh2tWrWib9++1KpVC2tr6yKlHReXXPhJr8nc3PCt5FNeB6a3MGPWhVj0RBaOVd6fEGxvq07eZ7JO1Mn6yE3WSW6yTtTlVx/v00iQj88ezM3L0K5dh5Iuiho/v4sEBj7iyy/7F3puYmIiv/46D1fX+SQmJnLtmj9t27Z/+4V8iRCCtLRMkpLSiItLxtrapFjXv/MhXXt7ewICAgB4/Pgx9evXJykpicTE7DiAXl5eAOjo6GBqakp0dPS7LmKJaVxOjylNzFh+7f+xd/fxbdb1/sff15WkSbO2y9qVdbB7oCsM2RgIKjcyhak7cnvE/dQpHgHZQESngCgHUeDgQIYoCCgeOPiTm8P5wTgoiiL3osgYTJ1sZWxj7L5bm/U2aZLr+v2RNE2Wdl23JFdz5fV8PPpIrpvk+uTTwt75XnftemVLxOlyAAA4IGedde6IC3uSdPzxH9CnP71vJ4VWV1fruuv+Q5LU2dmhl156voCVFU7RR/hqamp03nnn6ZZbbtHu3bt11VVXadmyZerp6dFFF12kl156SVu2bFF3d7dmzJihpqamYpfoqA9PDGh3r6Ulf92tG04y9b6x3IINADA4I9opIxY9oPewfX7Z/qpBl0ejEd1xx+0aP3681q59W2eccbb+8Iff6ZBDJmjbtm36yle+ps7ODv3853dpwoSJ2rTpPX3rW/+uG2+8Tg0N4/Wv/zpfV1/9DR1yyAR5vV7t2LFDN998m7xer+6//15ZlqXW1ladc86ndOihh+Vs/8Ybr9OuXbs0Y8ZRevvtNfrSl74svz+g737325o16xi1tbXJ7/fr7LP/Vb/97W9UW1srr9enz33uC7r++mu1bt07+sEPbtX3v//vuvDChXrzzRXatm2rvvOd67R48WWqrq5WVVWVduzYrrlzP6E//ekl1dcfpEsvvVwvvvi8/vM/f6b7739Qzzzze739drN+8Yt7dPDBh+juu+/QjTfeIq/Xo5/85DZdddU1mjRp8gH9LgrFkcuynHPOOVnTCxYsSD9funRpscsZcc48NKhwxNL3XgnrR3NqNaGaG6IAAAZgJVR7/4Uyew9sV7hVEdSui34lmQPf/emJJx7XxImT9OlPf0YbNqzXPffcqXnzPqmTTz5VjzzyK/3618s0duxBqqio0Gc+83m9/fYaSdInPvFJvfHG6wqFQjrjjLO1efMmXXTRIt12281au7ZZXq9P//znKt18823asWO7br75Rv3whz/O2f4nPvFJ/fa3v9YFF1ysjRvf1a23LtHtt/9UJ5/8YdXXH6QzzzxHa9e+rZtu+r5uu+1O1dTU6Oqrv6H169fpmmu+p8suu1h//OPvddFFizR79nE6+OBD9J//+TNJ0oIF5+u3v/21rrji2/rxj29VPB7XddfdqEWLkncUOeWUU/Xf//2gJOm00+Zq48YNuuCCiyVJv/vdbzRu3DglEgl97GPzRmzYk7i12oj1+SNHaVNnXD9cvls//HCtvFyjDwCwJ9Oj1i/em5cRvsHCniRt3LhB73//ByRJU6ZMVW9vr8aNS15Jo6FhvF577a8666x/1dq1zVq48N90yikfUVPTkTnvc/DBh0iSampGq7u7W21treroaNcvf3l/ev5gGhrGS5LGjz9Y7733bnr+hAkTJUmHHXa4Wlp2qKamRpI0blyDNmxYr0MPPUwXXbRIS5bcqM9+9gt7fe9Ro6rSn8vjGfrWpx/72Dz97ndPyeMxdeaZ5w65vpO408YIZRiGLjumRrt6LD28usvpcgAAI5Ttr5JVVXdAP3vbnStJkydP1fbtWyVJ69evU29vVNu2bZMkbd26RVOnTtW6dWv16U9/VnfffZ/+8pc/KRwO57yPYRg571tff5A+//kv6vOf/+Jej/fbvr1ve5s1ceKkAdeprz9I7e27JUnbtm3V1KlTJUmvv/6aPvrR0/U///PwXj/nUEzTlG3b2r07rLa2Vs2Zc5peeOFZdXZ2qqpq7z10GiN8I1h1hamvH1uj774S1nENfjXV+oZ+EQAAeXbmmWfrJz+5Tb/85X1qa2vVd75znf7rv36h9evfUUvLDl122WK99dYq3X33T9TQMF6NjU0KhUJ6+umntHXrFm3btlV/+tOLkqSZM4/RypVvqK2tVd/85tU6/PBG3Xvv3UokEpo1a/agNXR3d+n+++/VW2+t0qJFX9XOnTu1cuUb2rFju6ZOPVRjxozR4sVX6e6771BtbZ1mzHifpk07TD/96Y8VifToE5/4pBYvvkxjxtRq8+ZNeuedt7V27dt69tk/aOPGd7Vmzep0XRUVfm3fvk1//OPv5fcHtH37Nr388ov6wAc+pI6Odt111090/vkXaMyYWk2bdqiOOWbwukcKwy6l87uH0NLSUfBtOHHZgLtXtmv5tl795KO1qvSOvEFZLqWQi55kox+56EkuepJtsH5s2/auGhpG7rFihbBixXK98cbr6WPnRoJ4PC6Px6Nf/OIefelLX5ZpFvbf5/XrV+v55/+kY489TkcfPXPkX5YFw/dvR1XLY0r3/q3T6VIAACi6p59+SitXvqGtW7c4XUran//8sn70o1t0yCETCh728oFduiXA7zF0xXGjtfj5Vh0/3q8TxvudLgkAgIJYufJNbd78Xnq6trZOV199rYMVDezkk0/VySef6nQZ+4zAVyIOG+PT546s0u0r2vXTj9YpFBj53yYAAPnnngOxBjZz5izNnDnL6TJch9RQQj7VGNQhVR79+I32krq1DgAgf7xen7q62p0uA0XU0bFbPT0HdgcuRvhKiMcw9I3jRuvSP+7S0xt69PGp3GQcAMpNXV2DWlq2aNu2zTLL7BqthmGU5YBHT09Ea9a8I8tKqKJi/+7AReArMQ2jPLr46GrdvbJDR9dX6OAqfoUAUE5M09RBBx2iNWteVHPz6tQJA+URgioqfOrtjTldhkMMjRpVtd938yAtlKDTJwf0121R/XB5u245ZYw8ZfYNDwDKnWEYOumkk9XU1KRo9MDuslFKqqsr1dHR43QZjvB4PKqtrVMgENiv1xP4SlDfXTgueWaXHlnTpc8eMbKv7g0AyL/kSN84p8soKq7VuP84aaNEjfab+tqxNXpodZeaW8t1eBsAAOwLAl8Je3+DXx+fWqlblu9WJF4ex28AAIDhI/CVuAuOSt5a5Rf/KPxt5QAAQGki8JW4gDd5F47fre/Ra9vK58BdAACw7wh8LtBY69NnmkbpR6+3a3fUcrocAAAwwhD4XGL+9FEaN8qjn3AXDgAAsAcCn0t4TENXHFejFdt79Yd3D+z2KwAAwF0IfC4yvsqrLx9dpXv+1qGtXXGnywEAACMEgc9lPjalUjPrK3Tr8nYl2LULAABE4HMdwzD01WNqtKUzof9p5mrkAACAwOdKoYCpy2fX6Ff/7NTaNu7CAQBAuSPwudQJ4/06fXLyLhzRBLt2AQAoZwQ+F7vw6ColLOk+7sIBAEBZI/C5WKXX1DffP1q/WdejFdu5CwcAAOWKwOdyTbU+zZ8+Sktfb1c7d+EAAKAsEfjKwP9pGqWxlabueJO7cAAAUI4IfGXAaxr65nGj9dq2qJ7dyF04AAAoNwS+MjGh2qsL31etn67s0PauhNPlAACAIiLwlZF5Uyt11Fifbn19N3fhAACgjBD4yohhGLp8do02tsf12NvchQMAgHJB4CsztQGPvjq7Rr9c1al3wtyFAwCAckDgK0MfOjigj0wK6IfLd6uXu3AAAOB6BL4y9eWjqxVNSPev6nS6FAAAUGAEvjIV9Jn65nE1evKdbr2xg7twAADgZgS+MnZkXYU+1ThKS5e3q6OXu3AAAOBWXqcLgLM+d8Qovb49qp++2a6rjg8N67Uxy1YkbqunM6Yd7XH1xG1F4pZ64nb6J9L3mMieF0nYqvQYGuUzNMpnapTPUFVFxvPUY9900GfIYxgF6gIAAO5G4CtzfXfh+Oqzu3T3ynZV+cyccJZ8bmU8T86P73G+hymp0mco4DFU6TUU8CYf+34CXlMhv6lA0JDfaygSt9UVs9Tea2lLl6WuWHK6s9dWd2o7mYJeIxUM+0Nh0Geoyjd4UOxb5vcaMg3JY0gmwREAUGYIfNCkGq++fuxoPbW+OyOk9Yez7NC2Z5gzNa42qN7uiCrM5LX+8iVu2eruC4FZj8nnXRnztnfFcpZ175lIM5iGsgJg37RpSKZS4dDsX+ZJLzdkKuN5er3ktCe1zFfRrkQsIcMwZEjqa4uZ8Zh8aqTnGUb/MRb985LbU9+y1OvSy2XIa0oVHiP5k3ruH2Ta7zHk80h+s3/am+ffGwBg5CHwQZL04YkBfXhiYL9eG6r0KBzNf2DwmoZq/IZq/Pt3qGnC7guMtqIJW5ZtK2FJli1ZspWwU89tybLtjOfJ1yYfc5dlTvctT+yxzO/3qScSk21LtiTbttUXPy27/7F/XvKZbUuWJGU82pIsy1Yi47V2+rmtuGWrN2ErakmxRPKz9iZs9Sak3r5lCVuxQQ7TNCRVeFKhMRUEk2Ewe17mtC8jTPo8hnxm9nTf87516xJRRbvj8pnJwNn3nj7CJgAUBYEPruUxDFVXGKquKP62Q6GgwuGRdTcTy06GwJjVHwqjCVuxhBS19pjuC43pdZUKkbZilq2ueOp5wlavpfT83tR0LD2dXLa3U4J8WeFQ6ZDoMyWfachjJn+XXkPymMkRUW9qnic1z5OaZxrGHstSr00t82S+1kyO3PY/zx7pNZRc3xhgdDdrXmrUNbluxnsoudzIeM/M97W5vSGAIiLwAWXCNAwFvFJAhqqLvO2qmkq1tHYlA2cqSPaFz14rFRxTI5KZITJuJUdPE1Zy1DVu9Y++9j1PWMnd/9GEUuvb6fX35bWZ61lKLrczRm/tvtFb9Y+w5oMh5RznGux77jOzpzPmB/dYP5A6tMLvYbQUwOAIfAAKzmsmQ0mlC/6PY/ft0pfS4bBvt35/OLQzluVOJ2xb/mBAO9p61LPHme19P90xSzu6s5d1p06g6oklQ3Em01B2OPQaCnrNVFBMhsOg11AwFRqDvtQ6GdN9y/N9PC4A57ngf78AUDxG3+7i7LnDfp9QyK+DfYn9riNhJQNgZIAw2D/df5Z9d8xWa8RSdzyu7piVCpUDnxFvGsoIgWY6DA4WECvTYTK5vmkoZxd/r5U8jjSWPjSgf0Q3lhrRNX3d6uiOJdezMtZLHSKQ9Tw1Ihy37OQxpHucqLTnYQJ7W+7vOw51z3UzjzdNvbaqwpTPJAyj9BD4AKAEecz8HaNq2cng2BcAu1MBsTtzXkZIbI1Y2tSZXKc/OCanM7Oj11D6eMyKjFDlM410SOtfJo0yzNRocMZ6qaCVub4vI6x5DSMnXEb3eJ4+njQVksNRSzGr/1jVWOqQgP7DDQY//tSQFPKbGltpqj7o0dhKU2MrPaqvTD0PelQXSH6OUtJ3iIPUfzLZQIeZ9p9+Ntjy3GUDHQlhKHkZL66vWjwEPgAoc6aRGp3zHfh79SaSu699Hg37H/OReLJTwuo/yz2asNUetdTSk9DOHks7exJq6bG0bndUO7uT03E7GWbGBMwBw2B9al5dwJSnAKHQtpPhtb3XUkdv8jqn7b22OqJWap6tjpiVmrbT63TF7AGDWSEZUvpaqlU+U6Mqko9Vqeut9s3vuyh/dYWh8YZXdsTSqAqDkdZhIvABAPKmwuOuf4Q9pqFgRrA4KOjRYWMGTsaWbWt31FJLKgymQ2G3pbXhmHb2JLSrx1LcTp7FnQyFHtUHk4/9AdFUfaVHwWpb4YiVFd46MkJaR6+dsSw5v6PXyroEU9BrqKYiGZZqKkxV+03VVBgaP8qn6sz5Fab8Gb+7gX6Lffl9b8syl2etl3HtUCk5otgVs9WZCpudqYvud6aurdrSndD61PLM67Badlv6Lf0epQJhXzjMvjB/VYWpal/ygv0Vnr5rnhr9Z9qr/4x7Q8aA8/rW7bueanL5HuumX2OkT8Yaif8dEPgAAMgD0zA0JuDRmIBHjXsJheGolR4R7A+HCTW39YfChC1JO9Ov85pKB7OaCiP1aOqQKo+qK3zZoS61rKrCKLldy3tj27YqRlVq084udaWCYF8gzAyM7b22tnTGsoJkzLLT1z5NXh8140Sq9Lz8mDraqzs/Wpend8sfAh8AAEViGoZqAx7VBjxq1MChMGHb2h2xZPn9siJRVVckb1lZ7mdOG4ahURWmxgU9UtAz9AuGqe8C+XZGMOwLg1ZqWV9I7F+evHRT5rpB38j8PRH4AAAYQTyGodpKj0KhCoXDcafLKRt9t8Ic+KT7kRnihmP/7lkFAACAkuHICN/jjz+uDRs2qK2tTRdeeKEmTZqUXnbNNddowoQJ2r59u2bNmqWzzjrLiRIBAABco+iBr729XY8++qgefPBBbdy4UUuWLNGdd96ZXj516lRdcMEFisfj+shHPqIzzjhDpslAJAAAwP4qepJauXKlpk2bJkmaNGmSVq1albX8ggsukJTcl15RUVH2B6kCAAAcqKKP8IXDYQWDwfS0bduKxWLy+bLPVnryySf1pS99aViBLxQKDr3SAfJ4zKJsp5TQk1z0JBv9yEVPctGTbPQjFz3Zf0UPfKFQSN3d/VdSNwwjJ+z985//1DvvvKNvfOMbw3rvYlyhfSReCd5p9CQXPclGP3LRk1z0JBv9yEVP+tXXVw9r/aLv0p05c6bWrVsnSXr33Xc1Y8YMdXZ2qqOjQ5K0bt06PfHEE1q8eLHeeOMNtbW17e3tAAAAMISij/DV1NTovPPO0y233KLdu3frqquu0rJly9TT06OLLrpIF1xwgRoaGvSFL3xBLS0tuvfeezVmzJhilwkAAOAajlyW5ZxzzsmaXrBgQfr5c889V+xyAAAAXI3rnQAAALgcgQ8AAMDlCHwAAAAuR+ADAABwOQIfAACAyxH4AAAAXI7ABwAA4HIEPgAAAJcj8A2DvW6Neh5/SHYi4XQpAAAA+4zANxz+SvX8+n9kLb1GdnvY6WoAAAD2CYFvGIxDJil0y8+kRFzW974qe90ap0sCAAAYEoFvmMzaOpnfvEnGsSfK+sEVsp7/rWzbdrosAACAQXmdLqAUGV6vjM9eLGvadNn33y6tWy0tuERGhd/p0gAAAHIwwncAzA+cKvOapbKbV8m66QrZO7c7XRIAAEAOAt8BMiZMlXnt7dKYscnj+v7xutMlAQAAZCHw5YERHCXzK9fImHuOrNuvk/Xkw7Ity+myAAAAJHEMX94YpinjjP8je2qjrHuWyF7fLPPCxTKCVU6XBgAAyhwjfHlmHDVb5nd/LLXtlPX9r8netN7pkgAAQJkj8BWAMXaczKtvkdE4Q9YNi2X95XmnSwIAAGWMXboFYlT4pX/7mnToEbL/c6msdWtkfPoCGV5aDgAAiosRvgIyDEPmhz8u81u3yH79T7JuuVp2uNXpsgAAQJkh8BWBMW26zO/+RPJ6k5dueXuV0yUBAIAyQuArEqNmtMzFN8j40Edl3Xy1rD88wS3ZAABAUXBAWREZHo+M8/5N9rRGWfculdavkc7/qgx/wOnSAACAizHC5wDj2BNlXvsj2e++I+vGxbK3b3G6JAAA4GIEPocY4yfKvOY2GQ0TZH3/ctlvvup0SQAAwKUIfA4yKoMyFl0t44zPyLrzBlmP/1K2lXC6LAAA4DIcw+cwwzBkfPxc2ZMPlXX3D5K3ZPvylTKqqp0uDQAAuAQjfCOEccTM5KVberpkff+rst99x+mSAACASxD4RhCjdqzMK5fIeN9xsv7jG7L+9IzTJQEAABdgl+4IY/h8Mj5/qaxp02U/cIesrk6Zc892uiwAAFDCCHwjlHniabJHVcu680ZZNSGZHzjV6ZIAAECJYpfuCGbMOkHG+ZfJ/sVS2f9Y4XQ5AACgRBH4RjjzpNNlnPN5WXfeIHt9s9PlAACAEkTgKwHGJz4l45SPy7rtWtnbNjldDgAAKDEEvhJgGIaM+RfKmHGMrKX/Ljvc6nRJAACghBD4SoRhmjIuWCyNOzgZ+rq7nC4JAACUCAJfCTG8PpmXfEfyemX95PuyY71OlwQAAEoAga/EGJVBmV/7nhTeJetnN3PvXQAAMCQCXwkyakIyF98grX1L9v/9qWzbdrokAAAwghH4SpRR3yDz69fLfvUF2f/7oNPlAACAEYzAV8KMSdNkfvW7sn/z37Ke+43T5QAAgBGKwFfijOnvk3nxlbIfvFv28pedLgcAAIxABD4XMI49UcZnF8r62S2yV//N6XIAAMAIQ+BzCXPOv8j4l08nL9ey8R2nywEAACMIgc9FjDM/K+OEU5O3YNux1elyAADACEHgcxHDMGQsWCQddkTybhztYadLAgAAIwCBz2UM0yPzy1dKY+qSI3093U6XBAAAHEbgcyHDVyHzsmsly5J15w2y4zGnSwIAAA4i8LmUERwl8+vfl3ZslX3vUtmW5XRJAADAIQQ+FzNCtTK/cYPst96U/fDPuAUbAABlisDncsa4Q2R+7XuyX/q97KcedbocAADgAK8TG3388ce1YcMGtbW16cILL9SkSZPSyzo7O3XzzTcrHA7rxz/+sRPluY4xtVHmV66R9aPrZNWEZJ481+mSAABAERV9hK+9vV2PPvqovv71r+vCCy/UkiVLspb//e9/10knnVTsslzPmDFbxgWLZT/wE9lvvup0OQAAoIiKPsK3cuVKTZs2TZI0adIkrVq1Kmv5Bz/4Qb366v4FklAoeMD1DcXjMYuynYL4+Dz1xLvVffcPVHPdrfI1HZWXty3pnhQIPclGP3LRk1z0JBv9yEVP9l/RA184HFYw2P/Lsm1bsVhMPp8vD+9d+GvOhULBomynYE6aJ2PbdrXf+C2Z37pFxiGTD/gtS74nBUBPstGPXPQkFz3JRj9y0ZN+9fXVw1q/6Lt0Q6GQurv7f1mGYeQl7GHfGf/6RRnHfDB5N47WFqfLAQAABVb0wDdz5kytW7dOkvTuu+9qxowZ6uzsVEdHR7FLKVuGYcg4/6vSpGmybr1Gdme70yUBAIACKnrgq6mp0XnnnadbbrlFP//5z3XVVVdp2bJlevjhhyVJzc3NeuKJJ7Ru3To99thjxS6vbBgej8yF35KCVbJuv052NOJ0SQAAoEAM20VX421pKfwooduOH7A7O2Td9E2pvkHmV/5dhnfvh3XaliUlElI8lnxMxFQzqkLtrR1SIi7F4wM/JhJSIi47c9rjlXxeGV6f5KuQvD7J50s+9s3bc9rrlWEYRerO/nPb38mBoh+56EkuepKNfuSiJ/2GewyfI9fhw8hhVFXL/MYNsm78hqxvfzkZsBJ9YS2R8Tz1OMAt2sIDvbHHkwx0Hq/kTT16PP3PTU/qfWPJe/3GUj/xWHL+3ni9GQEwIyTmTPuSYdLrS27TkGQYkmEmn8tITe8xzzT2WGbsMV+p9VPB00wNlGe8T09lhayeIt3D2DCS/fSYqUfPHo+mjL5pwxxguSf5GQacn3pfI+P9TTNjvlkSARwAyh2BDzJq62V++4eyV72RDmSGNzOseSSPLxXYfP1hLrXO6Npq7e7qzVp2ICHAtqxk8ItnhMBYb/9037zUtN23LL1+b8brMkKkLcm2JduSErYkOzWd+smaVnLaslJPB1svc37/+8e8HtnxxAH+Zva1Yck6lUhIViL1aGU8T8hOL0vNz1y/b739ZZipEJgZCLPntXk9smTssc6e6+4x3fe+maE7K6j3PzekVPDuC+QDrW/015u1TsZ6gzd5vxZpLztQOisrZCWUGsH29n9Z8WSOdKdGwPuW5zzve4036zUH+t8gAPch8EGSZNQdJOOUj+3Xa81QUIbyN8RumKZU4U/+7Mv6edty/tSU2G4HOx2Es4NiTojse7T3nLZSITM1L3PaSigY8KqrsydjXkbwHHReon9EOStsS/2hO+O5lFrf7g/3Oev3BXMr+wuAlVpvb39Mew1Qe1k22Ovicam7J/mlJRHP+CIT7/8CE4/3j4BnrjPUKLiUGwwzv8Slp1Nf5rzJ+YbH2//FbaDXpEfp+1/TN5JvZL6vbfcfxtF3CEe8/9CO3Mfk8y6vIas7sscehkT/eyTiua+3rOxR5749CBkj1UbmqPVAI9nDWG74KiR/IPVTKfn9qcfkPMPjGfp3U0Zsy+r/76zvy2nff4upvymjby8JCorAByA5GmSk/lFT/i+T5A8F1VNCAbgYqg7gS4Ft23sEwz1CYVaAjKUOnegLXrH+wzTSx9TG+8Nm5jo93cnQmXloR9/xu3u8j5253DAyDusY5NGbO8+qLWFQhwAAIABJREFU9EsJ9QdLfyAV2DIPCdnjfUxP6stKKgRmjmTH49kj2unl8eReg75A2felJvMLzkBfevoCeDSS/In15v5yvD4pkBsE5Q/ISAfEQM4yBQIyKgKp1ybnJaKjZbd1ZH8R2OP3a+/5d5Des5H9xSHr72CgLxHxWP+XrcyAlv5CNEhoSy/fM9ilnu+LrC8Ye3yZyPzi4fOpPeBXwjZTo98Dr5Mzz5v6O5EyvpsZ2V/G0nsAjIzlGnxe5usz5hmGIdXWyzi0ad8+exER+ACgxBiGkfyHbRjXMB2JI+F7qi61kfFEQuqNSpEeqTciRVJBMNojRSPJqx/k/PRIXR2yd7XkvMaORpPPeyOSbeceH90XZAbajb/nLn+fLxmUM49xrhyVMRK756EEqWCUPhbZSI68ZR3nbGQcZtE3nfHcMPeYNjIOz9hjPan/y0Zf+EyH07jsRP/z/nVi8noNxTt7UvMz1kl/OdnjdX3htm/EX8rYA5Ca2PPQC3uoebb6D+XIPJwnNTVhsjxf/e6B/GkVBIEPAID9YHg8UmUw+TPQ8v18X9u2pd6oRgc92t0Z6z+es4yOyxzskwZDQfWW0JeCkYTABwDACGIYhuQPyKwOykgQbpAfHCkJAADgcgQ+AAAAlyPwAQAAuByBDwAAwOUIfAAAAC5H4AMAAHA5Ah8AAIDLEfgAAABcjsAHAADgcgQ+AAAAlyPwAQAAuByBDwAAwOUIfAAAAC5H4AMAAHA5Ah8AAIDLEfgAAABcjsAHAADgcgQ+AAAAlyPwAQAAuByBDwAAwOUIfAAAAC5H4AMAAHA5Ah8AAIDLEfgAAABcjsAHAADgcgQ+AAAAlyPwAQAAuByBDwAAwOUIfAAAAC5H4AMAAHA5Ah8AAIDLEfgAAABcjsAHAADgcgQ+AAAAlyPwAQAAuByBDwAAwOUIfAAAAC5H4AMAAHA5Ah8AAIDLEfgAAABcjsAHAADgcgQ+AAAAlyPwAQAAuByBDwAAwOUIfAAAAC7ndWKjjz/+uDZs2KC2tjZdeOGFmjRpUnrZ5s2bdc8996iurk4NDQ2aP3++EyWWLNu21RuLqLNnt7p62tUVaVd3T4c6I6npvp9Iu7p6dmdN98ai+7VN0zRkWXaeP0lpoyfZ6EcuepKLnmSjH7lKoSeTxzfp2gvud7qMHEUPfO3t7Xr00Uf14IMPauPGjVqyZInuvPPO9PKlS5fq4osvVmNjo84//3ydfvrpqq2tLXaZA0pYCa3b/JY62nuKsj3LttUT7Rw0oHX1dKhrgCAXT8TS7+ExvaqqHK1RlTUaVVmjYCD5WFVZo/rQIZoy/ojUstGq8Polwxh2naOCFerq7s3nRy959CQb/chFT3LRk2z0I1cp9KR+9HinSxhQ0QPfypUrNW3aNEnSpEmTtGrVqqzlK1asUGNjoySpsbFRy5cv19y5c/fpvUOhYH6L3cNzy5/Qd+/+UkG3sSeft0JVlaNVFaxRVXB08qcy+Vg3ZqqqU9OjgjXp+dV961aOlr+iUsZ+hLjh8HhMJRJWQbdRauhJNvqRi57koifZ6EcuerL/ih74wuGwgsH+YGbbtmKxmHw+nyQpGu3frRgMBhUOh4fx3t35K3QAxxx2up65a4t27y7sdvoZ8nkr9vvVkR4p0lP40chQKFjw3pcaepKNfuSiJ7noSTb6kYue9Kuvrx7W+kUPfKFQSN3d/b8swzDSYU+S/H5/+nl3d7dCoVBR6xtKhc8vnzfhdBkAAAD7rOhn6c6cOVPr1q2TJL377ruaMWOGOjs71dHRIUmaPXu2mpubJUnNzc067rjjil0iAACAqxR9hK+mpkbnnXeebrnlFu3evVtXXXWVli1bpp6eHl100UVavHix7rrrLtXW1mrevHkj5oQNAACAUmXYtj2yz28ehpaWjoJvg+MHctGTXPQkG/3IRU9y0ZNs9CMXPek33GP4uPAyAACAyxH4AAAAXI7ABwAA4HJDBr6Ojg5FIhH19vbqmWeeUXt7ezHqAgAAQJ4MGfi++93vauPGjbr55pv1m9/8RjfddFMx6gIAAECeDBn4jj76aB1++OF68803ddttt2nq1KnFqAsAAAB5MmTgW79+ve6++27Nnj1bktTa2lrwogAAAJA/Qwa+s846S21tbVq4cKGee+45TZgwoRh1AQAAIE+GvNPG7NmzNWXKFO3cuVPHH3+8Ro0aVYy6AAAAkCdDjvA98cQT+tznPqc777xTf/7zn3XXXXcVoy4AAADkyZCBb/Xq1frtb3+rGTNm6LTTTpOL7sQGAABQFoYMfNXVyXu1GYYhSbIsq7AVAQAAIK+GPIZv165duvbaa9XS0qIlS5YUoyYAAADk0ZAjfN/+9rc1Y8YMjR8/XlOnTtUVV1xRjLoAAACQJ0OO8Hk8Hs2fPz89/eabb2rWrFkFLQoAAAD5M2Tgu/rqq7Om16xZo8cee6xgBQEAACC/hgx8knTOOedIkrZs2aJx48YVtCAAAADk15CB7/vf/758Pl96+v777y9kPQAAAMizIQPfb37zm/Tzzs5OvfLKK/riF79YyJoAAACQR0Oepfv//t//06ZNm7Rp0ybFYjFde+21xagLAAAAeTLkCN/3vvc9TZs2LT0diUQKWhAAAADya9DA99prr6Wf79q1K/38iSee0A033FDYqgAAAJA3gwa+m266SdOnT8+Zv2bNmoIWBAAAgPwaNPB95zvf0bHHHpsz//XXXy9oQQAAAMivQU/ayAx73d3d2rJli7Zs2aJXXnmlKIUBAAAgP4Y8aeO+++7TE088oa6uLtXV1WnHjh267LLLilEbAAAA8mDIy7K0tLRo2bJlOu+88/Twww9rwYIFxagLAAAAeTJk4AsGg5Kkrq4uSdL69esLWxEAAADyasjAt337dj377LMaP368TjvtNLW0tBSjLgAAAOTJoMfwrV69Wk1NTbr++uvT82bNmqWpU6cWpTAAAADkx6AjfNddd53++te/Zs1ramqS3+8veFEAAADIn0ED31lnnaUdO3bo2muv1X333ae2trZi1gUAAIA8GXSX7mc+8xlJ0ic/+Ult2LBB999/v7q6unT66afrhBNOKFqBAAAAODBDnrQhSYcccogOP/xw/eMf/+AafAAAACVm0BG+l19+WRMmTNAjjzyiJ554QpMmTdJ5552nf/mXfylmfQAAADhAgwa+b37zm7JtW2eccYbuu+8+TZ8+vZh1AQAAIE8GDXynnHKKrr/+es7KBQAAKHF7vSwLYQ8AAKD0DRr4+m6pBgAAgNK2T2fpAgAAoHQNGfg+/elPa9WqVcWoBQAAAAUwZOCbMmWKZsyYkZ7mjhsAAAClZcjAN2nSJL344ovavHmztmzZop///OfFqAsAAAB5MuhlWfo8/PDDevXVV9PTW7du1ZVXXlnQogAAAJA/Qwa+xYsX69xzz01Pv/LKKwUtCAAAAPk1ZOA799xz9corr2j16tU64ogj9KEPfagYdQEAACBPhgx8d955p958801NnjxZr7zyilasWKFLL720GLUBAAAgD4YMfLFYLOtEjVtvvbWgBQEAACC/hjxL1zTNvU4DAABgZBtyhM/j8WjhwoWaOHGi3nvvPR199NHFqAsAAAB5MmTgu/TSS/Xyyy9rzZo1OvXUU3XiiScWoy4AAADkyZD7Z+fMmaMxY8boggsuIOwBAACUoCED34knnph1a7X33nvvgDa4efNmXXvttbr99tv1yCOPDLjO//7v/+qEE05QV1fXAW0LAAAA+xD4qqqq9NBDD+mvf/2rXnvtNd1zzz0HtMGlS5dqwYIFuvzyy/XUU0+ptbU1a/nOnTt18MEHa9SoUQe0HQAAACQNeQzfs88+q2OPPVZ/+9vfJElr1qw5oA2uWLFCjY2NkqTGxkYtX75cc+fOTS8fO3asxo4du1/vHQoFD6i2feHxmEXZTimhJ7noSTb6kYue5KIn2ehHLnqy/4YMfF/5ylc0b948eb3JVfuC3/6KRqPp58FgUOFw+IDeL1M43J239xpMKBQsynZKCT3JRU+y0Y9c9CQXPclGP3LRk3719dXDWn/IwLdkyRI1NTWlR+X25bIs4XBYixYtypm/cOFC+f3+9HR3d7dCodBw6gUAAMAwDRn45s6dmw57krRq1aqskzgGEgqF9NBDDw24bPbs2WpublZjY6Oam5vTwXDbtm1qaGgYTu0AAADYB0OetNHb26sf/vCHevzxx7Vs2bIDPmlj8eLFeuCBB7R06VLNmzdPtbW1am1t1SWXXJJe5+6771ZHR4fuvfdetbW1HdD2AAAAyp1h27a9txXOPvtsnXbaaenp1157Tf/1X/9V8ML2R0tLR8G3wfEDuehJLnqSjX7koie56Ek2+pGLnvTL+zF81113nWbNmpWe3rBhw7CLAgAAgHMG3aX7wAMP6I033sgKe3/5y1/061//uiiFAQAAID8GDXzvvfeepk6dqjvuuEN33HGHNm3apFmzZikWixWzPgAAABygQQPf6NGjFQqFNH/+fO3YsUMNDQ0KBAIKBALFrA8AAAAHaMizdOvr61VZWZm+8LJhGAUvCgAAAPkz6EkbL7/8srq7k2fCLF++XDfffLMkaeXKlVq4cGFxqgMAAMABGzTw+Xw+BYPJ+9XNmTOn/wXeIU/sBQAAwAgyaHq74oorBryN2j/+8Y+CFgQAAID8GvQYvsHumXvUUUcVrBgAAADk35AnbQAAAKC0EfgAAABcjsAHAADgcgQ+AAAAlyPwAQAAuByBDwAAwOUIfAAAAC5H4AMAAHA5Ah8AAIDLEfgAAABcjsAHAADgcgQ+AAAAlyPwAQAAuByBDwAAwOUIfAAAAC5H4AMAAHA5Ah8AAIDLEfgAAABcjsAHAADgcgQ+AAAAlyPwAQAAuByBDwAAwOUIfAAAAC5H4AMAAHA5Ah8AAIDLEfgAAABcjsAHAADgcgQ+AAAAlyPwAQAAuByBDwAAwOUIfAAAAC5H4AMAAHA5Ah8AAIDLEfgAAABcjsAHAADgcgQ+AAAAlyPwAQAAuByBDwAAwOUIfAAAAC5H4AMAAHA5Ah8AAIDLEfgAAABcjsAHAADgct5ib3Dz5s265557VFdXp4aGBs2fPz9r+VNPPaUVK1aorq5OmzZt0nXXXSefz1fsMgEAAFyj6CN8S5cu1YIFC3T55ZfrqaeeUmtra9bynTt36sorr9SiRYvk9/v1zDPPFLtEAAAAVyn6CN+KFSvU2NgoSWpsbNTy5cs1d+7c9PIvfOEL6eeWZSkQCOzze4dCwfwVOgiPxyzKdkoJPclFT7LRj1z0JBc9yUY/ctGT/Vf0wBeNRtPPg8GgwuHwgOuFw2Ft27ZNp5xyyj6/dzjcfcD1DSUUChZlO6WEnuSiJ9noRy56koueZKMfuehJv/r66mGtX5DAFw6HtWjRopz5CxculN/vT093d3crFArlrNfb26tbb71V119/vTweTyFKBAAAKBsFCXyhUEgPPfTQgMtmz56t5uZmNTY2qrm5OR0Mt23bpoaGBiUSCd188826+OKLVV9fr+eee05z5swpRJkAAABloei7dBcvXqy77rpLtbW1mjdvnmpra9Xa2qpLLrlEjz32mO644w698MILWrNmjSTp+OOPJ/ABAAAcAMO2bdvpIvKlpaWj4Nvg+IFc9CQXPclGP3LRk1z0JBv9yEVP+g33GD4uvAwAAOByBD4AAACXI/ABAAC4HIFvGIxIh9S2xekyAAAAhoXANwwV616V98GrJfec5wIAAMoAgW8YeqceL+3eId+WVU6XAgAAsM8IfMNgV9bIbjpJgVW/d7oUAACAfUbgGybrmE/Iv/YVGZFOp0sBAADYJwS+YbKnzJI1qlb+Nc87XQoAAMA+IfANl2EqcuRpqlz1e07eAAAAJYHAtx8iR3xUntaN8u5Y63QpAAAAQyLw7Qerqk69U45TYNXTTpcCAAAwJALfforM+Jj8zS9JvT1OlwIAALBXBL791Dt5tuyKSgXefsnpUgAAAPaKwLe/TI8iR56mwD//4HQlAAAAe0XgOwCRI06Td1uzPLvedboUAACAQRH4DoA1ukGxiTO58wYAABjRCHwHKDJjrgJrnpfivU6XAgAAMCAC3wGKTjtBkiH/uj87XQoAAMCACHwHyuNTpGmOAqs4eQMAAIxMBL48iMyYq4pNf5O5e6vTpQAAAOQg8OVBonaiYuOPUCWjfAAAYAQi8OVJz4y58r/1RykRd7oUAACALAS+PIkedqKMeFQV7y53uhQAAIAsBL588QUUbTyFa/IBAIARh8CXR5EZH1PFuytkdu50uhQAAIA0Al8exQ86VPGxUxT45zNOlwIAAJBG4MuzyIy5ycBnW06XAgAAIInAl3fRxg/L7AnL995Kp0sBAACQRODLO9s/StHDTuLkDQAAMGIQ+AqgZ8Zc+de9KqNnt9OlAAAAEPgKIT7+CCVGNyjw1rNOlwIAAEDgKwjDUOTI05O7dW3b6WoAAECZI/AVSOSIj8jTvl3erW85XQoAAChzBL4CsStHKzrtBFVy8gYAAHAYga+AIjPmyr/2ZRnRTqdLAQAAZYzAV0CxiTNlBUPyN7/odCkAAKCMEfgKyTD7T94AAABwCIGvwCJHfFTenRvk3fGO06UAAIAyReArMKtqrHonz1Zg1dNOlwIAAMoUga8IIjPmJo/ji0WcLgUAAJQhAl8R9E4+TrbXL//aPzldCgAAKEMEvmLweBU94qNckw8AADiCwFckPTNOl2/rW/K0bnS6FAAAUGYIfEVijR6v3glHK7DqD06XAgAAygyBr4giM05XYPWzUiLmdCkAAKCMEPiKKDrtg5Ik/7pXHa4EAACUEwJfMXkrFJl+KtfkAwAARUXgK7LIjLnyvfc3mbu3OV0KAAAoEwS+IkvUTVa8oVGBt55xuhQAAFAmCHwOiMyYq8A/n5GshNOlAACAMkDgc0DksJNk9Pao4t0VTpcCAADKgLfYG9y8ebPuuece1dXVqaGhQfPnz89a/sILL+jpp5/WxIkT1dzcrB/84Afy+/3FLrOwKioVbTxFgVVPq3fq+52uBgAAuFzRR/iWLl2qBQsW6PLLL9dTTz2l1tbWrOXRaFSLFy/WokWLVFVVpRdffLHYJRZFZMZcVWxYLrNzl9OlAAAAlyv6CN+KFSvU2NgoSWpsbNTy5cs1d+7c9PLM59u2bdPEiRP3+b1DoWD+Ch2Ex2PmZzujj5bqpyi04SVZJ332wN/PQXnriYvQk2z0Ixc9yUVPstGPXPRk/xU98EWj0fTzYDCocDics8727dv1ox/9SJMnT9b06dP3+b3D4e681Lg3oVAwb9sJNJ2m4Ov/q/CMMyWjdA+nzGdP3IKeZKMfuehJLnqSjX7koif96uurh7V+QQJfOBzWokWLcuYvXLgw63i87u5uhUKhnPXGjRunm266ST/96U/1wAMP6Pzzzy9EmY6LTj9VVX+6X75Nf1ds4kynywEAAC5VkMAXCoX00EMPDbhs9uzZam5uVmNjo5qbm9PBcNu2bWpoaNCyZct09tlnS5IOPvhgvfXWW4UocUSwA1WKHvYhBVb9nsAHAAAKpui7dBcvXqy77rpLtbW1mjdvnmpra9Xa2qpLLrlEjz32mHp7e3XDDTdo7NixWr16ta688spil1hUkRlzNXrZtersaZddWeN0OQAAwIUM27Ztp4vIl5aWjoJvI+/HD9i2xvzfRYq87xPqmXVW/t63iDimIhc9yUY/ctGTXPQkG/3IRU/6DfcYvtI9U8AtDEORI09XYNXvJfdkbwAAMIIQ+EaAyBEfkSe8Rd5ta5wuBQAAuBCBbwSwg2PUO/V4BVY97XQpAADAhQh8I0TPjLkKvP2yjF6OTQAAAPlF4BshYhNnyaqskb/ZnbeSAwAAziHwjRSmR5EjTkuevAEAAJBHBL4RJHLkafLueEeelnVOlwIAAFyEwDeCWNX16p08W5WM8gEAgDwi8I0wkSNPl3/NC1I86nQpAADAJQh8I0zv1OMlj1f+ta84XQoAAHAJAt9I4/EqcsRHOXkDAADkDYFvBIoceboqtqySp22T06UAAAAXIPCNQIkxh6j3kKMU+OcfnC4FAAC4AIFvhIoceboCbz0rJWJOlwIAAEocgW+Eih72ISkRV8WG5U6XAgAAShyBb6Ty+hU9/CQFVj/ndCUAAKDEEfhGsEjTHFVsWC4j0uF0KQAAoIQR+Eaw+PgjZFXVyf/2S06XAgAAShiBbyQzDEWmz2G3LgAAOCAEvhEu0nSqfNvWyBPe4nQpAACgRBH4RjgrdLBi45vkZ5QPAADsJwJfCYhMn6PAmuck23K6FAAAUIIIfCUgevhJMjtb5dvyltOlAACAEkTgKwF2oFq9U49nty4AANgvBL4SEWk6Vf61f5LiUadLAQAAJYbAVyJ6Jx8rmab8619zuhQAAFBiCHylwuNT9PCT5V/9rNOVAACAEkPgKyGRpo+o4t0VMrrDTpcCAABKCIGvhMTHHa7E6PEKNL/odCkAAKCEEPhKiWEo2jRH/jXPO10JAAAoIQS+EhOZfqp8O9bKs2uj06UAAIASQeArMVbNQeo95CgFuCYfAADYRwS+EhRtmiN/8wuSlXC6FAAAUAIIfCUoetiJMnva5dv8D6dLAQAAJYDAV4LsiqCi005gty4AANgnBL4SFW36iPzvvCLFIk6XAgAARjgCX4nqnTRLti8g/zt/droUAAAwwhH4SpXpUaTxwwpwTT4AADAEAl8JizTNke+9lTI7dzldCgAAGMEIfCUsMXaqErUTk5doAQAAGASBr5QZhiJNc5Jn69q209UAAIARisBX4qKNH5an9T15dq53uhQAADBCEfhKnFVVp9iEo7kmHwAAGBSBzwUiTXMU4FZrAABgEAQ+F4ge+kEZsYgqNr7pdCkAAGAEIvC5gS+g6KEflH8Nu3UBAEAuAp9LRJo+Iv87f5HR2+10KQAAYIQh8LlE7JCjZAWqVbH2FadLAQAAIwyBzy1Mj6LTT+VsXQAAkIPA5yKRpjmq2Px3me07nC4FAACMIAQ+F0nUTVKs/lAF1jzvdCkAAGAEIfC5TLRpjvzcag0AAGQoeuDbvHmzrr32Wt1+++165JFHBl3v/vvv17nnnlvEytwh0niKPLu3yrv9badLAQAAI0TRA9/SpUu1YMECXX755XrqqafU2tqas86GDRu0cePGYpfmCnYwpN7JsxXgmnwAACDFW+wNrlixQo2NjZKkxsZGLV++XHPnzk0vtyxLDzzwgL7whS/ozTeHd+eIUCiY11oH4vGYRdnOgTBmf1wVv/2xvJ/8iuTxFXx7pdCTYqMn2ehHLnqSi55kox+56Mn+K3rgi0aj6efBYFDhcDhr+YMPPqhPfepT8nqHX1o4XPiLDodCwaJs54CMm6m6RFzdK19W77QTCr65kuhJkdGTbPQjFz3JRU+y0Y9c9KRffX31sNYvSOALh8NatGhRzvyFCxfK7/enp7u7uxUKhbLWWbNmjbq7u7V7927t3LlTP/vZz3TRRRfJMIxClOpOXr+ih52kwOrnihL4AADAyFaQwBcKhfTQQw8NuGz27Nlqbm5WY2Ojmpub08Fw27Ztamho0PXXXy9J2rRpk/785z/ry1/+ciFKdL1o0xyNXvbvMiKdsgNVTpcDAAAcVPSTNhYvXqwHHnhAS5cu1bx581RbW6vW1lZdcskl6XXa2tr0q1/9Si0tLXr00UeLXaIrxA4+QlZVrfxrX3a6FAAA4DDDtt1zwbaWlo6Cb6OUjh8I/uVXqti0UuFP3VzQ7ZRST4qFnmSjH7noSS56ko1+5KIn/YZ7DB8XXnaxaNMc+baulrl7q9OlAAAABxH4XCwROlixhukKrOaafAAAlDMCn8tFmuYosPp5brUGAEAZI/C5XPSwk2R27pR361tOlwIAABxC4HM5u7JGvVOOY7cuAABljMBXBiJNc+R/+2Up3ut0KQAAwAEEvjLQO+U4yTRVseE1p0sBAAAOIPCVA49P0cNPZrcuAABlisBXJiJNp6ri3ddl9Ox2uhQAAFBkBL4yER83XYmacfI3v+R0KQAAoMgIfOXCMBRtmqPA6medrgQAABQZga+MRKafKt+OtfK0vud0KQAAoIgIfGXEqhmn3oNncPIGAABlhsBXZqJNc+Rf87xkW06XAgAAioTAV2aih50os2e3fJv/4XQpAACgSAh8Zcb2j1J02gfYrQsAQBkh8JWh6PRTVbH2FSkWdboUAABQBAS+MtQ76RjJWyH/ur84XQoAACgCAl858ngVmf5hrskHAECZIPCVqej0OfK9t1JmV6vTpQAAgAIj8JWpeP00JcZMkH/NC06XAgAACozAV64MQ5GmOQqsed7pSgAAQIER+MpYdPqH5dm5QZ6W9U6XAgAACojAV8asqrGKTTxagTVckw8AADcj8JW5yPQ5yeP4rITTpQAAgAIh8JW56KEflNnbLd97K50uBQAAFAiBr9xVVCp66AfZrQsAgIsR+KBI0xz53/mzjN5up0sBAAAFQOCDYhOOluWvSh7LZ1tOlwMAAPLM63QBGAFMjyJHfVzVz9+lqpfuVaK6Xlb1QUrUHJR6HJecVzNO1qgxksH3BAAASgmBD5Kk7vfPV+SIj8rsaJGnfbs8HTtktrfIt/nv8r/1R3k6WmRYcdmmNxX+DlKiepysmnoZ4ybK6w3JqjlIVnCMZHqc/jgAACADgQ9JhiGrul5Wdb3iBx+Zu9y2ZHa1yWzfLk8qFJodO+TbvEqe5ucVCm9PB0KreqwSe4wQpkcMR9USCAEAKDICH/aNYcqqqpNVVaf4HotCoaDCbZ0yu8My23fI07E9+di+Q76tb8m/5gV5OnbISMRkmx5ZVWOVqBoreXyOfJRi8Pg8Gh3j2oZ96EcuepKLnmQrdj+sUWMUHzs1/WNX1hRt23ll2zI7d8q7c4O8O9fJu3O9bG9A8fqMzxaodrrKojP/lIXnAAAdcUlEQVRs27adLiJfWlo6Cr6NUCiocJizWTPtU09sS0b3bnk6tsvTvkNm505XX+y5MuBTTyTmdBkjBv3IRU9y0ZNsxeyHkQ5J6+XduUFGPKpE1dhkQKqfqvjYaYqPnSJrdIOjx3Hn/HuTiMvT9p68LetTtSd/zEiHrEB1um4jHpW3ZZ28uzbIiPcqUV2fFW7j9dNk1RxUUseo19cPL7QS+IaJwJeLnuSiJ9noRy56koueZHOsH1ZCnt1b0yHKkwpRnq5WWb5KJcZOyQpK8bpJktdf8LKMaKdCka2KrH+rv65dG2VYccVHj1ciHUyTIdUaVScZRu5nC29NBcN18rasl2fXhuRnqwgqUTclayQwXjdZ8lYU/LPtj+EGPnbpAgCAfqZHiTETlBgzQdHGk9Ozje5w/yhay3pVrnxSnrZNkqTEmEOyQ+DYKbKDY/Zv+7Yts317/y7ZvuDZsUO2t0L+2smK109V5Mi5itdPVaJusuyK4L5/ttoJStTu+dnakttrWSfvzg2qfPMJedo2pz7bhIyRztQu4WBo/z6bgwh8AABgSHYwpNikYxSbdEz/zHhU3l0b00HQv/41BV/7b5mxHiWCY5TICkrTlAiNzz5xLxFLvX6dPOndshtk9nbJqhydCo/TFG08SfGx01Q95TCF26MF+GxjFJs0ZuDP1pI8DtC/7lUF//pI8rONqlV87NTU50sG3MTo8SP6pEQCHwAA2D9ev+LjDld83OH982xLZvuOdFDy7lwvf/OL8nS0yPZWKF43RYnqennbNiVHCG1bidDBio+dqt4px6n7uPOSo2ijBhghLGagGvSzbU+NOiZHH/1rnpenc6dsr1/xsVOSn+H984tX5z4i8AEAgPwxTFmjG9Q7ukG9h32of3ako/+kio4W9UycmTzmrm6y5Cv8MYB5YZiyRo9X7+jx2Z+tpz392UbqiR8EPgAAUHB2oFqxCUcrNuFop0vJO7uyRrGJMxWbONPpUgY1MmMoAAAA8obABwAA4HIEPgAAAJcj8AEAALgcgQ8AAMDlCHwAAAAuR+ADAABwOQIfAACAyxH4AAAAXI7ABwAA4HIEPgAAAJcj8AEAALict9gb3Lx5s+655x7V1dWpoaFB8+fPz1r+6quv6j/+4z9UU1MjSVq6dKnq6+uLXSYAAIBrFD3wLV26VBdffLEaGxt1/vnn6/TTT1dtbW3WOt/+9rd1wgknFLs0AAAAVyp64FuxYoUaGxslSY2NjVq+fLnmzp2btc6TTz6pv//976qsrNRnP/tZGYaxT+8dCgXzXu+ePB6zKNspJfQkFz3JRj9y0ZNc9CQb/chFT/Zf0QNfNBpNPw8GgwqHw1nLDzvsMF166aUaP368lixZoieffFJnnnnmPr13ONyd11oHEgoFi7KdUkJPctGTbPQjFz3JRU+y0Y9c9KRffX31sNYvSOALh8NatGhRzvyFCxfK7/enp7u7uxUKhbLWqaurSz+fNev/t3fvwU2V6QPHv2kaSkhvSem9aZoCLYXeBEoFhU4FVq3uriy6Oqij+4cKOro76g7iZUddxjLD7h8rqCy6roKoW0R38FLLVQWhpbbSC6V3bGPp1RKa9JKS9Pz+YJqlcln4rSWYPJ//ek7OOU/evu158rznfZNJcXHxJSd8QgghhBDiXOOS8IWGhvLee++dd9+sWbOor68nKSmJ+vp6d2LY0dFBVFQUW7du5Ve/+hVBQUGcOHGC2NjY8QhRCCGEEMJnXPEh3ccff5zXXnsNg8FAXl4eBoOB3t5eHn74YT788EOioqLIz8/HaDTS0tLCc889d6VDFEIIIYTwKipFURRPB/FT6e62jfs15PmBc0mbnEvaZCxpj3NJm5xL2mQsaY9zSZv8x+U+wycLLwshhBBCeDlJ+IQQQgghvJxXDekKIYQQQohzSYVPCCGEEMLLScInhBBCCOHlJOETQgghhPBykvAJIYQQQng5SfiEEEIIIbycJHxCCCGEEF5OEj4hhBBCCC8nCZ8QQgghhJeThE8IIYQQwstJwieEEOKK6e/v93QI4ionfWR8SMJ3HjU1NVRWVno6jKvGjh07+Pzzzz0dxlWloaGB1tZWAOTbCc+QfiIu5vjx46xatYoDBw7gcrk8Hc5Voauri9dff52Kigq6u7sBGBkZ8XBUniN9ZHxJwneWgYEB1q5dS3l5ORs3bmTnzp3YbDZPh+UxR48eZcWKFZSXl5Oenu7e7ssJjt1uJz8/ny+//JIXX3yRr7/+GpVK5emwPEr6ybk6OzvZuHEjX375pfuDgS/fyLds2cKKFSvIy8vjxhtvRK1Wezokj6uvr6egoACz2UxFRQUvvfQSAH5+vnlblj4y/tTPP//8854O4mrR09NDW1sb999/P5GRkezfv5/h4WGmTZvm6dA8oqCggGuuuYaVK1fS0NBAR0cH0dHRPp3gNDU1Ybfb+d3vfodOp+OTTz4hKiqKyMhIT4fmMdJPxuro6ODDDz8kMzOTjo4ONmzYwLJly3y2PQACAgLQaDRkZ2dTUFCAxWLBZrMRGxvLyMiIT7ZNd3c3+/btY8WKFWRkZLB161bsdjsZGRk+1Saj71X6yPjzzY8SF3Dy5El27twJwJw5c0hISKCxsZG2tjYPR3ZljVZm8vLyaGpqYtOmTdhsNjZs2MAbb7zB4OCghyO8chRFYXh42P3zwMAA27ZtA2DRokVERERQXFyMw+HwVIhXnMvlwmKxuH+WfjKWw+GgrKyMefPmcfvtt6NSqXjrrbcA36rynV3hnT59On5+fmzZsoUbb7wRjUZDfn4+Q0NDPlXROrtNgoKCmDx5Mt988w0ATz75JAUFBTgcDp9ok66uLuBMRVNRFOkjV4DPVvj279/Pvn376O/vJz4+HoDw8HB2795NXV0d8+fPJzg4mMLCQhYuXEhgYKCHIx5fhw8f5uOPP0atVhMdHQ2AXq9ncHCQjIwMZs+ezYwZM9i6dau7bbzdjh07ePvtt0lKSkKv16MoCjExMRw6dAiLxcLs2bMJCwtj8+bN/PKXv0Sj0Xg65HFXVFTEqlWrOHjwILfddhsg/eTHgoKCqKioYHBwkGnTppGcnMzatWu56667vL6PnDx5ks8//5zAwEBCQkKA/1RwUlNTmT59OkajkaSkJKqqqujr62PGjBkejnp8nThxgpdeeomUlJQxfw9Op5Pa2lr6+vpITEzEZDLR3NzMhAkT3Pckb9Te3s66des4dOgQs2bNQqvVAvh0H7lSfDLhO3DgAA0NDWRnZ7N582ba29u55pprAMjMzCQ/P5+8vDxiY2M5cuQIgYGBXvsHaLfbWb9+PYqiEBoaSlFRERqNhoSEBAASEhKYPHkyAGFhYZSWlqLX6937vdHQ0BD33Xcfp06d4tFHH3X/7keHFOLi4njllVe4+eabMRqNVFdXExER4dXDuj09PTz22GNYLBZWrVqFwWAgKiqKiRMnolKpfLKfWK1WPvnkE3Q6HTqdzv3MkcPh4OTJk9TU1JCSkkJCQgLNzc3YbDZSUlI8HPX42bVrF/v27cNms/HZZ5+RnJyMXq93/91oNBqCg4NxOBz4+/tTUVHBggULCAsL83Dk42fr1q2sX7+eG264gXnz5o3Zp9VqcTgcNDU10dHRQWpqKmVlZSxevJhJkyZ5KOLxoygK//jHP3jrrbeIiYkhPj7e3Sa+3EeuJH9PB+AJtbW1jIyMMGPGDB555BEeeughli5dil6vx2g0cvfdd/PWW2+h0+kIDg5m6tSpng553AwPDxMbG8vSpUvx9/ent7cXnU7n3u/n50ddXR0lJSWEh4ej1+tJTk72YMTjb+LEiSxZsoSYmBg6OjooLCwkLCyMm266Ca1WS1paGrm5uaxfv574+HhCQ0O9OrGBM8O4v/jFL7jjjjtwuVwUFRURGhrq/kfta/3kyJEjFBUVkZiYyLZt24iLi+Ouu+4CztzIMzIy+P7773n77bd54okniI2NZdasWR6Oenw4nU76+vooKyvj8ccfZ8KECaxevZqKigrMZjMjIyPuIbljx46xZ88eTp8+TXh4OCaTycPRj4/Tp08zPDyM3W5n7dq1+Pv7U1hYSHh4OKmpqUycOBGA6667jpiYGN588016enoICwsjKCgIRVG86pm1kZER2traaG5uZv369QQGBpKfn8+RI0fIzMwc81pf6SOe4JMVPrVazcGDB0lNTcVkMnH8+HH279/PokWLcDgcZGdnk5aWhp+fH8uWLfPq4dyAgABCQ0Pdn8T37t1LQkICMTExwJlqRWRkJHv27CEmJoZ77rnHq9tjVHJyMuvWrcNsNpOVlUVhYSGHDx9m4cKFAMyfP5/ExET8/Py48847CQgI8HDE40un05GQkEBAQAB+fn4cOnQIp9Pp/mc8PDzsE/1kaGgIf39/LBYLQ0NDLF++HK1Wy4EDB9xDuHCmyjlz5kx2795NTU0NGo2G66+/3qtmHlqtVp566ilcLheZmZmoVCoiIiKYMGECkyZNoq2tzX0zV6lUtLS0kJiYyMjICLNnzyYnJwd/f++qOYy2iaIopKam4nA4KC4upqmpidjYWLZt24bVaiUpKQl/f3+OHz/O1KlTSU1NJS0tjfnz56NWq70m2RttD6fTSVZWFlOmTCEsLAw/Pz9GRkZQFAWj0QicSQotFovX9xFP8tmEr6Ghga6uLtLT07n22mt5//33iYqKYseOHYSFhblLzt5OpVIREhLifs6mqqqKm266iaNHj9LU1MSuXbuIiIhgyZIlXl3p/DGNRkN6ejoZGRmEhYWRnp7OO++8g1ar5auvviIuLo6YmBif+fSpUqmYMGGCu/KgUqnQaDTExsbS0NDAO++8Q3x8PIsXL/bKfmK1Wlm9ejUASUlJVFZWuhOayMhIHA4HJSUlZGdno9FoqK+vJyYmhrlz55Kenu6+kXuTgYEB9u/fj8vlIjo6mvT0dCZMmADAnj17mDNnDmFhYbS0tGC323nhhRdYsmQJiYmJ6PV6D0c/PkbbxOl0EhcXR1JSEgCLFy9mypQpTJo0iaNHj5KUlERbWxurV6/mjjvuICgoaMzIirc4u49ERkZiNpvd1d6SkhKCg4PdCV9zczNr1qzx+j7iST6Z8Ol0OpxOJ3v37iU6OpqAgABOnz7trtqYzWZPh+gRKpWKjo4OFEVh06ZNDAwMcNtttxEXF+eTs6T0ej0jIyOo1Wra29vdfcRoNLr/Sfma0crDoUOHGB4eJikpCUVRSEpK8up+cvaNPCEhgbi4OLZu3UpCQgJGoxGVSoXFYiE5OZnOzk7Wrl3L4sWLCQwMdA/feZuAgABiYmL45ptvcLlcJCQkuBM+i8XC/Pnz2bBhAx0dHeTk5PDrX//avd9bnd0mTqeTpKQkTCaTu2oXEhJCYWEhS5YsIS4ujjvvvNNrqnnnc3Z7jIyMjOkjo8PcCxYsAMBgMPhEH/Ekn0z4AEwmExqNhqKiImpqapg5cyYpKSnumWW+RqVS0djYyNNPP01dXR0333wz9913n0/Oshw1PDzMoUOH2LJlC11dXaSkpJCRkYHBYPB0aB6n1Wr54osvmDdv3pgZmd7q7BvX0NAQc+fOxWazcfjwYUwmE0ajkZ07d5KTk0N0dLRP3LhUKhWRkZGo1Wq+/vproqOjiYqKAuDFF1/k3//+N/7+/tx///1eOQnhfH7cJlFRUURFRVFQUEBbWxtff/01JpPJ/ciQNyd7cPE+4nQ6sdvtmM1mr5+9frXw2YQPwGw2k5qaSm5urs9W9c5mt9vRarU8/fTTMg2eM0P/er0ePz8/li5dSmJioqdDumro9XqvHKa8kLNvXAcOHCAuLo4bbriBtrY2Dh8+TGlpKVOnTmXmzJk+cSM/W0JCAuXl5QwNDREYGEhjYyOtra088sgjLF++3GeSvbONtsng4KB7EfLu7m6ys7PJzc3F39/fJ/vI4OAgOp2OwMBARkZGiIuLk6HbK0il+PL3HwkhxGVat24d0dHR5OTkYDAYsNvt9Pf3+/QHgvLycp599lmuvfZaHn74YfcSPb5stE2ys7NZuXIlERERng7Jo8rLy3nuuefIyspi5cqVXr2M1dXKpyt8QghxubRaLS+//DKdnZ1kZGQQGRnp81WKzs5OoqOjefDBBwkKCvJ0OFeF0TZ56KGHfPrRmFFnt4e3PwJytZIKnxBCXIYjR45QU1PD7bff7vXP6V0qb1s37qcgbTKWtIfnScInhBCXQW5cQoifI+9cQ0EIIcaJJHtCiJ8jSfiEEEIIIbycJHxCCCGEEF5OEj4hhBBCCC8n30oshLhqLV++nIyMDKxWKzt37uS3v/0tACdPnmTt2rWXfJ5Dhw7x1VdfsWrVqou+7m9/+xupqaksWrTof4ob4F//+hfr1q3j1ltvJSwsDIDi4mJee+21n2yZjh07dvDnP/+Z0tLSn+R8QgjvJbN0hRBXre3bt7Ns2TLq6+tZsWIFe/fuHbP9clzK7NqfegbuDTfcwMaNG0lKSgLgwIEDZGVlERAQ8JNeY7RdhBDiQqTCJ4S4al0oqVu2bBnr1q3j008/5Te/+Q0VFRUkJiaSnZ3Nnj17MJvN1NXV8cILLxAYGEh+fj41NTVs2bKFN954g1deeYVHH32Uo0ePYrPZeO211+js7GTNmjWkpKTw6KOP8oc//IHW1lbmzp1LY2Mj6enpPPbYYwBs2rSJhoYGEhMTKS8vR6PR8OyzzxITE3PB97Jp0yby8vIICAhg8+bNbNy4kXvvvZeBgQGOHz/OmjVrCA0NZffu3Rw8eJCoqCgsFgurVq0iMDCQ3bt3c+DAAWJjYzly5AhPPfUURqMRgH/+859UV1djt9t59dVXUavVvPjii0RGRmKz2YiMjOTee+/96X9BQoifD0UIIa5ydXV1Sm5u7jnbU1NTFavVqjidTqWmpkYpKSlR+vr6FEVRlDfffFN55513FEVRFIvFotxzzz3u43Jzc5WmpiZFURTlgQceUKqqqhRFUZTt27crL7/8svuYhQsXKk6nU3E6ncr111/vjuXmm292n+uJJ55Qtm/fft64c3NzlSeffFJZs2aNctdddykWi8W9Ly0tTbHb7YqiKMrf//53Ze3atYrValUWLFigOBwO9/a//vWv52wvLi5WWlpa3Nc4fvy4oiiK8uCDDypVVVWK1WpVcnJylI6ODkVRFKWsrOzSGloI4bWkwieE+NmaPHmy+2uaUlJSqK6u5pVXXkGv13P06FGmTZt2wWPNZjMABoOB/v7+877GaDSiVqsB0Gg0ADQ2NhIfHz/mNRfzwAMPkJSURFtb25jvmDUYDOh0OgBMJhOlpaW0tLQQEhLi/gYPk8nE9u3bz9menZ095homkwkAvV5Pf38/ISEhPPPMMzzzzDM4HA5Wrlx50RiFEN5PZukKIX62fvy83bPPPsuiRYt46KGHuO666y7r2Et9zZQpU2hpaXH/bLFYLinW2NhYqqur6evrA6C3t9edaH733XdMnToVk8nEqVOnGB4eBqClpYWUlJRztpeUlNDU1HTBOPv6+tDr9bzxxhv86U9/Ij8//5JiFEJ4L/Xzzz//vKeDEEKICxkaGuL111+nsrISg8HAjBkzANi2bRv79u1Do9FwzTXXAOB0OikoKKCjo4OysjKam5uZNWsW77//Pt9++y0JCQkcO3aMoqIiDAYDiqKwbds2fvjhB2bMmMGWLVtobm4mLS2Njz76iG+++YakpCRqa2spLCzEYDCwcOFCbDYb7733Hi0tLbS3t2M2m0lJSRkT9wcffMDevXtxuVxUV1dTWlrKxx9/zLx58wgODubdd98lICCAnTt3Ultbyx//+Ef0ej1Go5EtW7Zw7NgxLBYLv//97wkODnZvr6+vp7a2lptuuomdO3ee973MnTuXl19+GYvFwrfffktubq673YQQvklm6QohxGWqrKwkPT0dgNWrV7Ns2TLmzJlzWeeQ2bVCiCtJhnSFEOIybd68mVdffZUNGzYQGRl52cne1q1bsdls7NixY5wiFP8fLpeLzz77jKqqqnG/1uDgINu3b6e1tXXcr3Uxw8PD7N+/n23btl0V5zlba2srb7/9Nm1tbf/Teerr69m0aRN2u/28+6uqqnj11Vcv65ifI5m0IYQQl+kvf/nL/3T83Xffzd133/0TRSN+Kmq1+r9Owjmfd999l+XLl1/WMVqtlsjIyMu+1qXat28foaGh9Pf3ExwcTHp6OqdOnaKsrAyDwYDD4SA7OxuHw8H06dNpb293H9vW1kZ9fT0RERH09PSwYMEC/Pz+Ux+61PP8t3iqq6vp7OwkPDycrq4uFi9ePOYYnU43ZqITnFls3Gg0MjQ0REhIyDmPKrz33nsYDAYAFi1ahL+/P2FhYQQGBp43LpfLRVxcnHtS1qiLHfNzJQmfEEIIn9TZ2UljY6N7tnRmZqZ738jICEVFRURERNDb20tfXx95eXmUlZURFBREb28vqampDA0N0d/fT0VFBbGxsXz88cfMmDGDrq4uUlNTaWpqIjIykt7eXnJycjh16pR7PcXOzk7i4+MZHh7m4MGDREREcOLECebNm0dVVRXNzc1MmzaNEydOEBcXh0qloq+vj+TkZKKjoy/63mbNmkVISAjDw8MUFBSQnp5OSUkJaWlpREdH88EHHzBz5kyCgoIYGRkZc2xtbS1ms5nExET27dtHQ0MDycnJ7v2Xep7/Fk9UVBTNzc1otVqqq6vJyckZk3iNfkPN2aKiorDZbPT09NDb23tOwhcUFERcXBxOpxN/f/8LnmeUWq1Gr9efs/1ix/xcyZCuEEIInzRp0iTUajVqtZrq6uox+44fP45Wq2X27NmYzWYiIyMZGBigt7eXjIwM0tLSOHjwIEajEZ1OR0ZGBpMnTyYiIgKz2cwtt9xCfHw8QUFBKIqCxWLBbrdTXl5OSkoKmZmZ7kTj6NGjDAwM4HK5mDhxIp2dnaSkpKDVasnKyuKWW27BZrPR399PSkrKmKrXDz/8wK5duygrKxsT/+hyRZWVlSxcuBAAq9XqTm4nTZrknjH+Y9deey09PT0cO3aMoaEh7HY71dXV7Nq1i/b29ks+T2lpKbt27cJqtZ43nrKyMmbPns28efPIy8s7p8r2Y06nk7q6OhYuXMitt97qTvaKioo4deoUAIsXL2bmzJn09/dz7NixC57ro48+wul0XvR63kYqfEIIIXxSSUkJU6ZMwWw2U1lZeUnHjM5zPHspHJVKxdnzHwMCAvDz86O+vt495Nna2orL5TrvOVUqFeHh4aSlpdHX1+dOREbXXfT39ycrK4uBgQGKi4uZMmWKO9kJCwtjyZIl543zyJEjxMbGotVqAcYMqQ4MDFzwO51VKhWZmZlMmDCBEydOEBERgdFoJDU19bLOk5WVddF4+vv70Wq1qFQqamtrCQkJuegwt9PpdLe7n58fX3zxBWazmRtvvBE4sxzR6NDzpEmTLri+JsDSpUsvuM9bybIsQgghfJKiKNTU1DA4OEhTUxMxMTHU19fT19fHnDlzqK2txWaz0d3djZ+fH9OnT6enp4eTJ0/S0tLC7Nmz0el0NDY20tXVhZ+fH3V1dcCZdRc1Gg2VlZWcPn2apqYmdDodycnJlJeX09/fj8ViweVyMWvWLHccra2tmM1mmpub+e6774iOjkan01FSUoLT6cTlchEbG0tQUNBF39unn35Kd3c3VquVyspK0tLSmDx5MpWVlVitVgIDA0lMTMThcFBVVcX3339PSEgIBoOBEydOUFxczODgIAAzZ84cc+5LPc9/iyc4OJjq6mpOnTqF1WolMzNzzLOCra2t1NXV4XK5CA8Pd1cTu7u7qaurw2QyERMTQ2FhIREREQwPD1NaWsrAwADt7e1kZWWh0WhobGykvr4etVpNREQEarWa7du3M23aNNRqNTU1NTQ2NjJx4kR3wnm+Y37uZFkWIYQQ4jx6e3sxGAzU1dVhs9kueza2EFcTGdIVQgghzuOrr77CZDLR3d3N9ddf7+lwhPifSIVPCCGEEMLLySxdIYQQQggvJwmfEEIIIYSXk4RPCCGEEMLLScInhBBCCOHlJOETQgghhPBy/wfeLVsKYDCJuAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 648x648 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_res = plot_fit_history.plot_dnn_fit_history(\n",
    "    df=relu_history.history,\n",
    "    title=(\n",
    "        f'ReLU DNN Errors Over Training Epochs\\n'\n",
    "        f'Training Data: s3://{s3_bucket}/{s3_key}\\n'\n",
    "        f'Created: {created_on}'),\n",
    "    red='mean_squared_error',\n",
    "    blue='mean_absolute_error',\n",
    "    green='acc',  # accuracy\n",
    "    orange='cosine_proximity')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Determine Sigmoid Errors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 648x648 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_res = plot_fit_history.plot_dnn_fit_history(\n",
    "    df=sigmoid_history.history,\n",
    "    title=(\n",
    "        f'Sigmoid DNN Errors Over Training Epochs\\n'\n",
    "        f'Training Data: s3://{s3_bucket}/{s3_key}\\n'\n",
    "        f'Created: {created_on}'),\n",
    "    red='mean_squared_error',\n",
    "    blue='mean_absolute_error',\n",
    "    green='acc',  # accuracy\n",
    "    orange='cosine_proximity')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Run Predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run Control Predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "making control predictions: 390\n",
      "390/390 [==============================] - ETA:  - 0s 188us/step\n",
      "Average historical close vs control predicted close error: -0.03\n"
     ]
    }
   ],
   "source": [
    "print(\n",
    "    f'making control predictions: {len(control_predict_records)}')\n",
    "\n",
    "control_predictions = dnn_control_estimator.model.predict(\n",
    "    control_predict_records,\n",
    "    verbose=True)\n",
    "\n",
    "np.set_printoptions(threshold=np.nan)\n",
    "indexes = tf.argmax(control_predictions, axis=1)\n",
    "data = {}\n",
    "data['indexes'] = indexes\n",
    "control_price_predictions = [ae_consts.to_f(x[0]) for x in control_predictions]\n",
    "\n",
    "timeseries_df['control_close'] = control_price_predictions\n",
    "timeseries_df['control_error'] = (\n",
    "    timeseries_df['close'] -\n",
    "    timeseries_df['control_close'])\n",
    "control_average_error = ae_consts.to_f(\n",
    "    timeseries_df['control_error'].sum() / len(timeseries_df.index))\n",
    "\n",
    "print(\n",
    "    f'Average historical close '\n",
    "    f'vs control predicted close error: '\n",
    "    f'{control_average_error}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run ReLU Predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "making relu predictions: 390\n",
      "390/390 [==============================] - ETA:  - 0s 223us/step\n",
      "Average historical close vs relu predicted close error: -0.06\n"
     ]
    }
   ],
   "source": [
    "print(\n",
    "    f'making relu predictions: {len(predict_records)}')\n",
    "\n",
    "relu_predictions = dnn_relu_estimator.model.predict(\n",
    "    predict_records,\n",
    "    verbose=True)\n",
    "\n",
    "np.set_printoptions(threshold=np.nan)\n",
    "indexes = tf.argmax(relu_predictions, axis=1)\n",
    "data = {}\n",
    "data['indexes'] = indexes\n",
    "\n",
    "# inverse the scaled predictions back to floats:\n",
    "relu_price_predictions = [\n",
    "    ae_consts.to_f(x) for x in\n",
    "    scaler_predictions.inverse_transform(\n",
    "        relu_predictions.reshape(-1, 1)).reshape(-1)]\n",
    "\n",
    "timeseries_df['relu_close'] = relu_price_predictions\n",
    "timeseries_df['relu_error'] = (\n",
    "    timeseries_df['close'] -\n",
    "    timeseries_df['relu_close'])\n",
    "relu_average_error = ae_consts.to_f(\n",
    "    timeseries_df['relu_error'].sum() / len(timeseries_df.index))\n",
    "\n",
    "print(\n",
    "    f'Average historical close '\n",
    "    f'vs relu predicted close error: '\n",
    "    f'{relu_average_error}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Run Sigmoid Predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "making sigmoid predictions: 390\n",
      "390/390 [==============================] - ETA:  - 0s 251us/step\n",
      "Average historical close vs sigmoid predicted close error: -0.11\n"
     ]
    }
   ],
   "source": [
    "print(\n",
    "    f'making sigmoid predictions: {len(predict_records)}')\n",
    "\n",
    "sigmoid_predictions = dnn_sigmoid_estimator.model.predict(\n",
    "    predict_records,\n",
    "    verbose=True)\n",
    "\n",
    "np.set_printoptions(threshold=np.nan)\n",
    "indexes = tf.argmax(sigmoid_predictions, axis=1)\n",
    "data = {}\n",
    "data['indexes'] = indexes\n",
    "\n",
    "# inverse the scaled predictions back to floats:\n",
    "sigmoid_price_predictions = [\n",
    "    ae_consts.to_f(x) for x in\n",
    "    scaler_predictions.inverse_transform(\n",
    "        sigmoid_predictions.reshape(-1, 1)).reshape(-1)]\n",
    "\n",
    "timeseries_df['sigmoid_close'] = sigmoid_price_predictions\n",
    "timeseries_df['sigmoid_error'] = (\n",
    "    timeseries_df['close'] -\n",
    "    timeseries_df['sigmoid_close'])\n",
    "sigmoid_average_error = ae_consts.to_f(\n",
    "    timeseries_df['sigmoid_error'].sum() / len(timeseries_df.index))\n",
    "\n",
    "print(\n",
    "    f'Average historical close '\n",
    "    f'vs sigmoid predicted close error: '\n",
    "    f'{sigmoid_average_error}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plot Historical Close vs DNNs' Predicted Close"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "plotting historical close vs predicted close for control\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\n",
    "    f'plotting historical close vs predicted close for control')\n",
    "\n",
    "plot_res = plot_trading_history.plot_trading_history(\n",
    "    title=(\n",
    "        f'{ticker} - Historical Close vs Predicted Close\\n'\n",
    "        f'{date_str}\\n'\n",
    "        f'DNNs: Control + ReLU + Sigmoid\\n'\n",
    "        f'Training Data: s3://{s3_bucket}/{s3_key}\\n'),\n",
    "    df=copy.deepcopy(timeseries_df),\n",
    "    red='close',\n",
    "    blue='control_close',\n",
    "    green='relu_close',\n",
    "    orange='sigmoid_close',\n",
    "    date_col='minute',\n",
    "    date_format='%d %H:%M:%S\\n%b',\n",
    "    xlabel='minute',\n",
    "    ylabel='Historical Close vs Predicted Close',\n",
    "    df_filter=df_filter,\n",
    "    width=10.0,\n",
    "    height=10.0,\n",
    "    show_plot=True,\n",
    "    dropna_for_all=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Next Steps: Can you beat the Control dnn's predictions?\n",
    "\n",
    "Not surprising to see the **control** dnn winning over and over again. With the **close** price bounded between the **high** and **low** training feature values, the **control** neural network's regression predictions using **ReLU** are always more precise to the actual historical **close** price (at least for the **SPY** with this one day of pricing data).\n",
    "\n",
    "#### So why continue with scaler normalization?\n",
    "\n",
    "Preprocessing the dataset using scaler normalization ([MinMaxScaler](https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html)) resulted in worse regression predictions. The loss of accuracy and precision is hard to justify for regression predictions with this demo dataset and additional scaler normalization processing overhead. For background, scaler normalization in this notebook bounded all the numeric data values between a known float range ([[-1, 1]](https://github.com/AlgoTraders/stock-analysis-engine/blob/master/analysis_engine/ai/build_scaler_dataset_from_df.py#L16) by default) so the dnn could learn from many columns of different data types and values. So while the regression accuracy is hard to compete with, being able to add new, custom columns to a dataset that works with a dnn's **fit** function enables for more feature-rich learning than the control dnn's limited [**high**, **low**, **open**] feature set.\n",
    "\n",
    "As long as a column can be converted to a float/numeric type the dnn can use it. Getting the weights right appears to be the next challenge (please open an [issue if you know how to fix or improve this](https://github.com/AlgoTraders/stock-analysis-engine/issues/new)). For now, the more indicators and output report variables you add to an indicator, the more features (columns) your trading history dataset will have (and hopefully you can beat the control dnn!).\n",
    "\n",
    "Finally, why were the scaler normalized **ReLU** DNN's predictions worse than **Sigmoid** DNN's? [It sounds like **ReLU** needs a different preprocessing step than a **MinMaxScaler**.](https://datascience.stackexchange.com/questions/25832/input-normalization-for-relu)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Considerations, Disclaimers and Legal\n",
    "\n",
    "- This tool is for educational use to research how dnn's work, data preprocessing, new AI ideas, analysis pipelines of custom datasets, and dnn prediction speed vs prediction quality.\n",
    "- This notebook is showing just 1 day of pricing data. To keep up with live intraday pricing datafeeds and lots of historical pricing data, you would want to run the rest of the engine's stack (using [docker-compose](https://github.com/AlgoTraders/stock-analysis-engine#running-the-full-stack-locally-for-backtesting-and-live-trading-analysis) or [kubernetes](https://github.com/AlgoTraders/stock-analysis-engine/tree/master/k8)).\n",
    "- Use this tool at your own risk when trading with your own funds. This is fully open source and there are no promises on how well any of this works with real money. It is still being actively developed and is not for live trading use. If you lose money because \"the data said to trade\" it's not this tool or its owners', creators' or maintainers' fault. No one involed in this project is responsible or liable for how you use this data. Buyer/seller beware."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
